import { z } from 'zod';
import { A as ActionRef, a as ActionRefSchema, E as EventSchema, G as GuardRefSchema, b as StateMachineConfig, c as StateMachineSchema, S as StateNodeConfig, d as StateNodeSchema, T as Transition, e as TransitionSchema } from './state-machine.zod-DoC0JvQb.js';

/**
 * Trigger events for workflow automation
 */
declare const WorkflowTriggerType: z.ZodEnum<{
    schedule: "schedule";
    on_update: "on_update";
    on_create: "on_create";
    on_create_or_update: "on_create_or_update";
    on_delete: "on_delete";
}>;
/**
 * Schema for Workflow Field Update Action
 * @example
 * {
 *   name: "update_status",
 *   type: "field_update",
 *   field: "status",
 *   value: "approved"
 * }
 */
declare const FieldUpdateActionSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"field_update">;
    field: z.ZodString;
    value: z.ZodUnknown;
}, z.core.$strip>;
/**
 * Schema for Workflow Email Alert Action
 * @example
 * {
 *   name: "send_approval_email",
 *   type: "email_alert",
 *   template: "approval_request_email",
 *   recipients: ["user_id_123", "manager_field"]
 * }
 */
declare const EmailAlertActionSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"email_alert">;
    template: z.ZodString;
    recipients: z.ZodArray<z.ZodString>;
}, z.core.$strip>;
/**
 * Schema for Connector Action Reference
 * Executes a capability defined in an integration connector.
 * Replaces hardcoded vendor actions (Slack, Twilio, etc).
 *
 * @example Send Slack Message
 * {
 *   name: "notify_slack",
 *   type: "connector_action",
 *   connectorId: "slack",
 *   actionId: "post_message",
 *   input: {
 *     channel: "#general",
 *     text: "New deal closed: {name}"
 *   }
 * }
 */
declare const ConnectorActionRefSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"connector_action">;
    connectorId: z.ZodString;
    actionId: z.ZodString;
    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>;
/**
 * Schema for HTTP Callout Action
 * Makes a REST API call to an external service.
 * @example
 * {
 *   name: "sync_to_erp",
 *   type: "http_call",
 *   url: "https://erp.api/orders",
 *   method: "POST",
 *   headers: { "Authorization": "Bearer {token}" },
 *   body: "{ ... }"
 * }
 */
declare const HttpCallActionSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"http_call">;
    url: z.ZodString;
    method: z.ZodDefault<z.ZodEnum<{
        GET: "GET";
        POST: "POST";
        PUT: "PUT";
        DELETE: "DELETE";
        PATCH: "PATCH";
    }>>;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    body: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/**
 * Schema for Workflow Task Creation Action
 * @example
 * {
 *   name: "create_followup_task",
 *   type: "task_creation",
 *   taskObject: "tasks",
 *   subject: "Follow up with client",
 *   dueDate: "TODAY() + 3"
 * }
 */
declare const TaskCreationActionSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"task_creation">;
    taskObject: z.ZodString;
    subject: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    assignedTo: z.ZodOptional<z.ZodString>;
    dueDate: z.ZodOptional<z.ZodString>;
    priority: z.ZodOptional<z.ZodString>;
    relatedTo: z.ZodOptional<z.ZodString>;
    additionalFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
/**
 * Schema for Workflow Push Notification Action
 */
declare const PushNotificationActionSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"push_notification">;
    title: z.ZodString;
    body: z.ZodString;
    recipients: z.ZodArray<z.ZodString>;
    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    badge: z.ZodOptional<z.ZodNumber>;
    sound: z.ZodOptional<z.ZodString>;
    clickAction: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/**
 * Schema for Workflow Custom Script Action
 */
declare const CustomScriptActionSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"custom_script">;
    language: z.ZodDefault<z.ZodEnum<{
        javascript: "javascript";
        typescript: "typescript";
        python: "python";
    }>>;
    code: z.ZodString;
    timeout: z.ZodDefault<z.ZodNumber>;
    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
/**
 * Universal Workflow Action Schema
 * Union of all supported action types.
 */
declare const WorkflowActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"field_update">;
    field: z.ZodString;
    value: z.ZodUnknown;
}, z.core.$strip>, z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"email_alert">;
    template: z.ZodString;
    recipients: z.ZodArray<z.ZodString>;
}, z.core.$strip>, z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"http_call">;
    url: z.ZodString;
    method: z.ZodDefault<z.ZodEnum<{
        GET: "GET";
        POST: "POST";
        PUT: "PUT";
        DELETE: "DELETE";
        PATCH: "PATCH";
    }>>;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    body: z.ZodOptional<z.ZodString>;
}, z.core.$strip>, z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"connector_action">;
    connectorId: z.ZodString;
    actionId: z.ZodString;
    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"task_creation">;
    taskObject: z.ZodString;
    subject: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    assignedTo: z.ZodOptional<z.ZodString>;
    dueDate: z.ZodOptional<z.ZodString>;
    priority: z.ZodOptional<z.ZodString>;
    relatedTo: z.ZodOptional<z.ZodString>;
    additionalFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>, z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"push_notification">;
    title: z.ZodString;
    body: z.ZodString;
    recipients: z.ZodArray<z.ZodString>;
    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    badge: z.ZodOptional<z.ZodNumber>;
    sound: z.ZodOptional<z.ZodString>;
    clickAction: z.ZodOptional<z.ZodString>;
}, z.core.$strip>, z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"custom_script">;
    language: z.ZodDefault<z.ZodEnum<{
        javascript: "javascript";
        typescript: "typescript";
        python: "python";
    }>>;
    code: z.ZodString;
    timeout: z.ZodDefault<z.ZodNumber>;
    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>], "type">;
type WorkflowAction = z.infer<typeof WorkflowActionSchema>;
/**
 * Time Trigger Definition
 * Schedules actions to run relative to a specific time or date field.
 */
declare const TimeTriggerSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    timeLength: z.ZodNumber;
    timeUnit: z.ZodEnum<{
        days: "days";
        minutes: "minutes";
        hours: "hours";
    }>;
    offsetDirection: z.ZodEnum<{
        before: "before";
        after: "after";
    }>;
    offsetFrom: z.ZodEnum<{
        trigger_date: "trigger_date";
        date_field: "date_field";
    }>;
    dateField: z.ZodOptional<z.ZodString>;
    actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"field_update">;
        field: z.ZodString;
        value: z.ZodUnknown;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"email_alert">;
        template: z.ZodString;
        recipients: z.ZodArray<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"http_call">;
        url: z.ZodString;
        method: z.ZodDefault<z.ZodEnum<{
            GET: "GET";
            POST: "POST";
            PUT: "PUT";
            DELETE: "DELETE";
            PATCH: "PATCH";
        }>>;
        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        body: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"connector_action">;
        connectorId: z.ZodString;
        actionId: z.ZodString;
        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"task_creation">;
        taskObject: z.ZodString;
        subject: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        assignedTo: z.ZodOptional<z.ZodString>;
        dueDate: z.ZodOptional<z.ZodString>;
        priority: z.ZodOptional<z.ZodString>;
        relatedTo: z.ZodOptional<z.ZodString>;
        additionalFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"push_notification">;
        title: z.ZodString;
        body: z.ZodString;
        recipients: z.ZodArray<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        badge: z.ZodOptional<z.ZodNumber>;
        sound: z.ZodOptional<z.ZodString>;
        clickAction: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"custom_script">;
        language: z.ZodDefault<z.ZodEnum<{
            javascript: "javascript";
            typescript: "typescript";
            python: "python";
        }>>;
        code: z.ZodString;
        timeout: z.ZodDefault<z.ZodNumber>;
        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>;
/**
 * Schema for Workflow Rules (Automation)
 *
 * **NAMING CONVENTION:**
 * Workflow names are machine identifiers and must be lowercase snake_case.
 *
 * @example Good workflow names
 * - 'send_welcome_email'
 * - 'update_lead_status'
 * - 'notify_manager_on_close'
 * - 'calculate_discount'
 *
 * @example Bad workflow names (will be rejected)
 * - 'SendWelcomeEmail' (PascalCase)
 * - 'updateLeadStatus' (camelCase)
 * - 'Send Welcome Email' (spaces)
 *
 * @example Complete Workflow
 * {
 *   name: "new_lead_process",
 *   objectName: "lead",
 *   triggerType: "on_create",
 *   criteria: "amount > 1000",
 *   active: true,
 *   actions: [
 *     {
 *       name: "set_status",
 *       type: "field_update",
 *       field: "status",
 *       value: "new"
 *     },
 *     {
 *       name: "notify_team",
 *       type: "connector_action",
 *       connectorId: "slack",
 *       actionId: "post_message",
 *       input: { channel: "#sales", text: "New high value lead!" }
 *     }
 *   ],
 *   timeTriggers: [
 *     {
 *       timeLength: 2,
 *       timeUnit: "days",
 *       offsetDirection: "after",
 *       offsetFrom: "trigger_date",
 *       actions: [
 *         {
 *           name: "followup_check",
 *           type: "task_creation",
 *           taskObject: "task",
 *           subject: "Follow up lead",
 *           dueDate: "TODAY()"
 *         }
 *       ]
 *     }
 *   ]
 * }
 */
declare const WorkflowRuleSchema: z.ZodObject<{
    name: z.ZodString;
    objectName: z.ZodString;
    triggerType: z.ZodEnum<{
        schedule: "schedule";
        on_update: "on_update";
        on_create: "on_create";
        on_create_or_update: "on_create_or_update";
        on_delete: "on_delete";
    }>;
    criteria: z.ZodOptional<z.ZodString>;
    actions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"field_update">;
        field: z.ZodString;
        value: z.ZodUnknown;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"email_alert">;
        template: z.ZodString;
        recipients: z.ZodArray<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"http_call">;
        url: z.ZodString;
        method: z.ZodDefault<z.ZodEnum<{
            GET: "GET";
            POST: "POST";
            PUT: "PUT";
            DELETE: "DELETE";
            PATCH: "PATCH";
        }>>;
        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        body: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"connector_action">;
        connectorId: z.ZodString;
        actionId: z.ZodString;
        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"task_creation">;
        taskObject: z.ZodString;
        subject: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        assignedTo: z.ZodOptional<z.ZodString>;
        dueDate: z.ZodOptional<z.ZodString>;
        priority: z.ZodOptional<z.ZodString>;
        relatedTo: z.ZodOptional<z.ZodString>;
        additionalFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"push_notification">;
        title: z.ZodString;
        body: z.ZodString;
        recipients: z.ZodArray<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        badge: z.ZodOptional<z.ZodNumber>;
        sound: z.ZodOptional<z.ZodString>;
        clickAction: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"custom_script">;
        language: z.ZodDefault<z.ZodEnum<{
            javascript: "javascript";
            typescript: "typescript";
            python: "python";
        }>>;
        code: z.ZodString;
        timeout: z.ZodDefault<z.ZodNumber>;
        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>], "type">>>;
    timeTriggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        timeLength: z.ZodNumber;
        timeUnit: z.ZodEnum<{
            days: "days";
            minutes: "minutes";
            hours: "hours";
        }>;
        offsetDirection: z.ZodEnum<{
            before: "before";
            after: "after";
        }>;
        offsetFrom: z.ZodEnum<{
            trigger_date: "trigger_date";
            date_field: "date_field";
        }>;
        dateField: z.ZodOptional<z.ZodString>;
        actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"field_update">;
            field: z.ZodString;
            value: z.ZodUnknown;
        }, z.core.$strip>, z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"email_alert">;
            template: z.ZodString;
            recipients: z.ZodArray<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"http_call">;
            url: z.ZodString;
            method: z.ZodDefault<z.ZodEnum<{
                GET: "GET";
                POST: "POST";
                PUT: "PUT";
                DELETE: "DELETE";
                PATCH: "PATCH";
            }>>;
            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            body: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"connector_action">;
            connectorId: z.ZodString;
            actionId: z.ZodString;
            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strip>, z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"task_creation">;
            taskObject: z.ZodString;
            subject: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            assignedTo: z.ZodOptional<z.ZodString>;
            dueDate: z.ZodOptional<z.ZodString>;
            priority: z.ZodOptional<z.ZodString>;
            relatedTo: z.ZodOptional<z.ZodString>;
            additionalFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>, z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"push_notification">;
            title: z.ZodString;
            body: z.ZodString;
            recipients: z.ZodArray<z.ZodString>;
            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            badge: z.ZodOptional<z.ZodNumber>;
            sound: z.ZodOptional<z.ZodString>;
            clickAction: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"custom_script">;
            language: z.ZodDefault<z.ZodEnum<{
                javascript: "javascript";
                typescript: "typescript";
                python: "python";
            }>>;
            code: z.ZodString;
            timeout: z.ZodDefault<z.ZodNumber>;
            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>], "type">>;
    }, z.core.$strip>>>;
    active: z.ZodDefault<z.ZodBoolean>;
    executionOrder: z.ZodDefault<z.ZodNumber>;
    reevaluateOnChange: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
type WorkflowRule = z.infer<typeof WorkflowRuleSchema>;
type TimeTrigger = z.infer<typeof TimeTriggerSchema>;

/**
 * Flow Node Types
 */
declare const FlowNodeAction: z.ZodEnum<{
    loop: "loop";
    start: "start";
    end: "end";
    script: "script";
    decision: "decision";
    create_record: "create_record";
    update_record: "update_record";
    delete_record: "delete_record";
    wait: "wait";
    connector_action: "connector_action";
    assignment: "assignment";
    get_record: "get_record";
    http_request: "http_request";
    screen: "screen";
    subflow: "subflow";
}>;
/**
 * Flow Variable Schema
 * Variables available within the flow execution context.
 */
declare const FlowVariableSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodString;
    isInput: z.ZodDefault<z.ZodBoolean>;
    isOutput: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
/**
 * Flow Node Schema
 * A single step in the visual logic graph.
 *
 * @example Decision Node
 * {
 *   id: "dec_1",
 *   type: "decision",
 *   label: "Is High Value?",
 *   config: {
 *     conditions: [
 *       { label: "Yes", expression: "{amount} > 10000" },
 *       { label: "No", expression: "true" } // default
 *     ]
 *   },
 *   position: { x: 300, y: 200 }
 * }
 */
declare const FlowNodeSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<{
        loop: "loop";
        start: "start";
        end: "end";
        script: "script";
        decision: "decision";
        create_record: "create_record";
        update_record: "update_record";
        delete_record: "delete_record";
        wait: "wait";
        connector_action: "connector_action";
        assignment: "assignment";
        get_record: "get_record";
        http_request: "http_request";
        screen: "screen";
        subflow: "subflow";
    }>;
    label: z.ZodString;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    connectorConfig: z.ZodOptional<z.ZodObject<{
        connectorId: z.ZodString;
        actionId: z.ZodString;
        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strip>>;
    position: z.ZodOptional<z.ZodObject<{
        x: z.ZodNumber;
        y: z.ZodNumber;
    }, z.core.$strip>>;
}, z.core.$strip>;
/**
 * Flow Edge Schema
 * Connections between nodes.
 */
declare const FlowEdgeSchema: z.ZodObject<{
    id: z.ZodString;
    source: z.ZodString;
    target: z.ZodString;
    condition: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        default: "default";
        fault: "fault";
    }>>;
    label: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/**
 * Flow Schema
 * Visual Business Logic Orchestration.
 *
 * @example Simple Approval Logic
 * {
 *   name: "approve_order_flow",
 *   label: "Approve Large Orders",
 *   type: "record_change",
 *   status: "active",
 *   nodes: [
 *     { id: "start", type: "start", label: "Start", position: {x: 0, y: 0} },
 *     { id: "check_amount", type: "decision", label: "Check Amount", position: {x: 0, y: 100} },
 *     { id: "auto_approve", type: "update_record", label: "Auto Approve", position: {x: -100, y: 200} },
 *     { id: "submit_for_approval", type: "connector_action", label: "Submit", position: {x: 100, y: 200} }
 *   ],
 *   edges: [
 *     { id: "e1", source: "start", target: "check_amount" },
 *     { id: "e2", source: "check_amount", target: "auto_approve", condition: "{amount} < 500" },
 *     { id: "e3", source: "check_amount", target: "submit_for_approval", condition: "{amount} >= 500" }
 *   ]
 * }
 */
declare const FlowSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    version: z.ZodDefault<z.ZodNumber>;
    status: z.ZodDefault<z.ZodEnum<{
        active: "active";
        draft: "draft";
        obsolete: "obsolete";
        invalid: "invalid";
    }>>;
    template: z.ZodDefault<z.ZodBoolean>;
    type: z.ZodEnum<{
        api: "api";
        schedule: "schedule";
        screen: "screen";
        autolaunched: "autolaunched";
        record_change: "record_change";
    }>;
    variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodString;
        isInput: z.ZodDefault<z.ZodBoolean>;
        isOutput: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>>;
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<{
            loop: "loop";
            start: "start";
            end: "end";
            script: "script";
            decision: "decision";
            create_record: "create_record";
            update_record: "update_record";
            delete_record: "delete_record";
            wait: "wait";
            connector_action: "connector_action";
            assignment: "assignment";
            get_record: "get_record";
            http_request: "http_request";
            screen: "screen";
            subflow: "subflow";
        }>;
        label: z.ZodString;
        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        connectorConfig: z.ZodOptional<z.ZodObject<{
            connectorId: z.ZodString;
            actionId: z.ZodString;
            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strip>>;
        position: z.ZodOptional<z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    edges: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source: z.ZodString;
        target: z.ZodString;
        condition: z.ZodOptional<z.ZodString>;
        type: z.ZodDefault<z.ZodEnum<{
            default: "default";
            fault: "fault";
        }>>;
        label: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    active: z.ZodDefault<z.ZodBoolean>;
    runAs: z.ZodDefault<z.ZodEnum<{
        user: "user";
        system: "system";
    }>>;
    errorHandling: z.ZodOptional<z.ZodObject<{
        strategy: z.ZodDefault<z.ZodEnum<{
            continue: "continue";
            retry: "retry";
            fail: "fail";
        }>>;
        maxRetries: z.ZodDefault<z.ZodNumber>;
        retryDelayMs: z.ZodDefault<z.ZodNumber>;
        fallbackNodeId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
/**
 * Type-safe factory for creating flow definitions.
 *
 * Validates the config at creation time using Zod `.parse()`.
 *
 * @example
 * ```ts
 * const onCreateFlow = defineFlow({
 *   name: 'on_task_create',
 *   label: 'On Task Create',
 *   type: 'record_change',
 *   nodes: [
 *     { id: 'start', type: 'start', label: 'Start' },
 *     { id: 'end', type: 'end', label: 'End' },
 *   ],
 *   edges: [{ id: 'e1', source: 'start', target: 'end' }],
 * });
 * ```
 */
declare function defineFlow(config: z.input<typeof FlowSchema>): FlowParsed;
type Flow = z.input<typeof FlowSchema>;
type FlowParsed = z.infer<typeof FlowSchema>;
type FlowNode = z.input<typeof FlowNodeSchema>;
type FlowNodeParsed = z.infer<typeof FlowNodeSchema>;
type FlowEdge = z.input<typeof FlowEdgeSchema>;
type FlowEdgeParsed = z.infer<typeof FlowEdgeSchema>;

/**
 * Webhook Trigger Event
 * When should this webhook fire?
 */
declare const WebhookTriggerType: z.ZodEnum<{
    update: "update";
    delete: "delete";
    create: "create";
    api: "api";
    undelete: "undelete";
}>;
/**
 * CANONICAL WEBHOOK DEFINITION
 *
 * This is the single source of truth for webhook configuration across ObjectStack.
 * All other protocols (workflow, connector, etc.) should import and reference this schema.
 *
 * Webhook Protocol - Outbound HTTP Integration
 * Push data to external URLs when events occur in the system.
 *
 * **NAMING CONVENTION:**
 * Webhook names are machine identifiers and must be lowercase snake_case.
 *
 * @example Good webhook names
 * - 'stripe_payment_sync'
 * - 'slack_notification'
 * - 'crm_lead_export'
 *
 * @example Bad webhook names (will be rejected)
 * - 'StripePaymentSync' (PascalCase)
 * - 'slackNotification' (camelCase)
 *
 * @example Basic webhook configuration
 * ```typescript
 * const webhook: Webhook = {
 *   name: 'slack_notification',
 *   label: 'Slack Order Notification',
 *   object: 'order',
 *   triggers: ['create', 'update'],
 *   url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXX',
 *   method: 'POST',
 *   headers: { 'Content-Type': 'application/json' },
 *   authentication: {
 *     type: 'bearer',
 *     credentials: { token: process.env.SLACK_TOKEN }
 *   },
 *   retryPolicy: {
 *     maxRetries: 3,
 *     backoffStrategy: 'exponential'
 *   }
 * }
 * ```
 */
declare const WebhookSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodOptional<z.ZodString>;
    object: z.ZodOptional<z.ZodString>;
    triggers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        update: "update";
        delete: "delete";
        create: "create";
        api: "api";
        undelete: "undelete";
    }>>>;
    url: z.ZodString;
    method: z.ZodDefault<z.ZodEnum<{
        GET: "GET";
        POST: "POST";
        PUT: "PUT";
        DELETE: "DELETE";
        PATCH: "PATCH";
    }>>;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    body: z.ZodOptional<z.ZodUnknown>;
    payloadFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
    includeSession: z.ZodDefault<z.ZodBoolean>;
    authentication: z.ZodOptional<z.ZodObject<{
        type: z.ZodEnum<{
            none: "none";
            "api-key": "api-key";
            basic: "basic";
            bearer: "bearer";
        }>;
        credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strip>>;
    retryPolicy: z.ZodOptional<z.ZodObject<{
        maxRetries: z.ZodDefault<z.ZodNumber>;
        backoffStrategy: z.ZodDefault<z.ZodEnum<{
            fixed: "fixed";
            linear: "linear";
            exponential: "exponential";
        }>>;
        initialDelayMs: z.ZodDefault<z.ZodNumber>;
        maxDelayMs: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    timeoutMs: z.ZodDefault<z.ZodNumber>;
    secret: z.ZodOptional<z.ZodString>;
    isActive: z.ZodDefault<z.ZodBoolean>;
    description: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
/**
 * Webhook Receiver Schema (Inbound)
 * Handling incoming HTTP hooks from Stripe, Slack, etc.
 *
 * **NAMING CONVENTION:**
 * Webhook receiver names are machine identifiers and must be lowercase snake_case.
 *
 * @example Good names
 * - 'stripe_webhook_handler'
 * - 'github_events'
 * - 'twilio_status_callback'
 *
 * @example Bad names (will be rejected)
 * - 'StripeWebhookHandler' (PascalCase)
 */
declare const WebhookReceiverSchema: z.ZodObject<{
    name: z.ZodString;
    path: z.ZodString;
    verificationType: z.ZodDefault<z.ZodEnum<{
        none: "none";
        header_token: "header_token";
        hmac: "hmac";
        ip_whitelist: "ip_whitelist";
    }>>;
    verificationParams: z.ZodOptional<z.ZodObject<{
        header: z.ZodOptional<z.ZodString>;
        secret: z.ZodOptional<z.ZodString>;
        ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    action: z.ZodDefault<z.ZodEnum<{
        script: "script";
        trigger_flow: "trigger_flow";
        upsert_record: "upsert_record";
    }>>;
    target: z.ZodString;
}, z.core.$strip>;
type Webhook = z.infer<typeof WebhookSchema>;
type WebhookReceiver = z.infer<typeof WebhookReceiverSchema>;

/**
 * Approval Step Approver Type
 */
declare const ApproverType: z.ZodEnum<{
    field: "field";
    user: "user";
    role: "role";
    queue: "queue";
    manager: "manager";
}>;
/**
 * Approval Action Type
 * Actions to execute on transition
 */
declare const ApprovalActionType: z.ZodEnum<{
    script: "script";
    webhook: "webhook";
    field_update: "field_update";
    email_alert: "email_alert";
    connector_action: "connector_action";
}>;
/**
 * definition of an action to perform
 */
declare const ApprovalActionSchema: z.ZodObject<{
    type: z.ZodEnum<{
        script: "script";
        webhook: "webhook";
        field_update: "field_update";
        email_alert: "email_alert";
        connector_action: "connector_action";
    }>;
    name: z.ZodString;
    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    connectorId: z.ZodOptional<z.ZodString>;
    actionId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/**
 * Approval Process Step
 */
declare const ApprovalStepSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    entryCriteria: z.ZodOptional<z.ZodString>;
    approvers: z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            field: "field";
            user: "user";
            role: "role";
            queue: "queue";
            manager: "manager";
        }>;
        value: z.ZodString;
    }, z.core.$strip>>;
    behavior: z.ZodDefault<z.ZodEnum<{
        first_response: "first_response";
        unanimous: "unanimous";
    }>>;
    rejectionBehavior: z.ZodDefault<z.ZodEnum<{
        reject_process: "reject_process";
        back_to_previous: "back_to_previous";
    }>>;
    onApprove: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    onReject: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
/**
 * Approval Process Protocol
 *
 * Defines a complex review and approval cycle for a record.
 * Manages state locking, notifications, and transition logic.
 */
declare const ApprovalProcessSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    object: z.ZodString;
    active: z.ZodDefault<z.ZodBoolean>;
    description: z.ZodOptional<z.ZodString>;
    entryCriteria: z.ZodOptional<z.ZodString>;
    lockRecord: z.ZodDefault<z.ZodBoolean>;
    steps: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        entryCriteria: z.ZodOptional<z.ZodString>;
        approvers: z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                field: "field";
                user: "user";
                role: "role";
                queue: "queue";
                manager: "manager";
            }>;
            value: z.ZodString;
        }, z.core.$strip>>;
        behavior: z.ZodDefault<z.ZodEnum<{
            first_response: "first_response";
            unanimous: "unanimous";
        }>>;
        rejectionBehavior: z.ZodDefault<z.ZodEnum<{
            reject_process: "reject_process";
            back_to_previous: "back_to_previous";
        }>>;
        onApprove: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                script: "script";
                webhook: "webhook";
                field_update: "field_update";
                email_alert: "email_alert";
                connector_action: "connector_action";
            }>;
            name: z.ZodString;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            connectorId: z.ZodOptional<z.ZodString>;
            actionId: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        onReject: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                script: "script";
                webhook: "webhook";
                field_update: "field_update";
                email_alert: "email_alert";
                connector_action: "connector_action";
            }>;
            name: z.ZodString;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            connectorId: z.ZodOptional<z.ZodString>;
            actionId: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
    }, z.core.$strip>>;
    escalation: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        timeoutHours: z.ZodNumber;
        action: z.ZodDefault<z.ZodEnum<{
            notify: "notify";
            auto_approve: "auto_approve";
            reassign: "reassign";
            auto_reject: "auto_reject";
        }>>;
        escalateTo: z.ZodOptional<z.ZodString>;
        notifySubmitter: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    onSubmit: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    onFinalApprove: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    onFinalReject: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    onRecall: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
declare const ApprovalProcess: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    object: z.ZodString;
    active: z.ZodDefault<z.ZodBoolean>;
    description: z.ZodOptional<z.ZodString>;
    entryCriteria: z.ZodOptional<z.ZodString>;
    lockRecord: z.ZodDefault<z.ZodBoolean>;
    steps: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        entryCriteria: z.ZodOptional<z.ZodString>;
        approvers: z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                field: "field";
                user: "user";
                role: "role";
                queue: "queue";
                manager: "manager";
            }>;
            value: z.ZodString;
        }, z.core.$strip>>;
        behavior: z.ZodDefault<z.ZodEnum<{
            first_response: "first_response";
            unanimous: "unanimous";
        }>>;
        rejectionBehavior: z.ZodDefault<z.ZodEnum<{
            reject_process: "reject_process";
            back_to_previous: "back_to_previous";
        }>>;
        onApprove: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                script: "script";
                webhook: "webhook";
                field_update: "field_update";
                email_alert: "email_alert";
                connector_action: "connector_action";
            }>;
            name: z.ZodString;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            connectorId: z.ZodOptional<z.ZodString>;
            actionId: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        onReject: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                script: "script";
                webhook: "webhook";
                field_update: "field_update";
                email_alert: "email_alert";
                connector_action: "connector_action";
            }>;
            name: z.ZodString;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            connectorId: z.ZodOptional<z.ZodString>;
            actionId: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
    }, z.core.$strip>>;
    escalation: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        timeoutHours: z.ZodNumber;
        action: z.ZodDefault<z.ZodEnum<{
            notify: "notify";
            auto_approve: "auto_approve";
            reassign: "reassign";
            auto_reject: "auto_reject";
        }>>;
        escalateTo: z.ZodOptional<z.ZodString>;
        notifySubmitter: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    onSubmit: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    onFinalApprove: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    onFinalReject: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    onRecall: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            script: "script";
            webhook: "webhook";
            field_update: "field_update";
            email_alert: "email_alert";
            connector_action: "connector_action";
        }>;
        name: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        connectorId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
}, z.core.$strip> & {
    create: <T extends z.input<typeof ApprovalProcessSchema>>(config: T) => T;
};
type ApprovalProcess = z.infer<typeof ApprovalProcessSchema>;
type ApprovalStep = z.infer<typeof ApprovalStepSchema>;

/**
 * ETL (Extract, Transform, Load) Pipeline Protocol - LEVEL 2: Data Engineering
 *
 * Inspired by modern data integration platforms like Airbyte, Fivetran, and Apache NiFi.
 *
 * **Positioning in 3-Layer Architecture:**
 * - **L1: Simple Sync** (automation/sync.zod.ts) - Business users - Sync Salesforce to Sheets
 * - **L2: ETL Pipeline** (THIS FILE) - Data engineers - Aggregate 10 sources to warehouse
 * - **L3: Enterprise Connector** (integration/connector.zod.ts) - System integrators - Full SAP integration
 *
 * ETL pipelines enable automated data synchronization between systems, transforming
 * data as it moves from source to destination.
 *
 * **SCOPE: Advanced multi-source, multi-stage transformations.**
 * Supports complex operations: joins, aggregations, filtering, custom SQL.
 *
 * ## When to Use This Layer
 *
 * **Use ETL Pipeline when:**
 * - Combining data from multiple sources
 * - Need aggregations, joins, transformations
 * - Building data warehouses or analytics platforms
 * - Complex data transformations required
 *
 * **Examples:**
 * - Sales data from Salesforce + Marketing from HubSpot → Data Warehouse
 * - Multi-region databases → Consolidated reporting
 * - Legacy system migration with transformation
 *
 * **When to downgrade:**
 * - Simple 1:1 sync → Use {@link file://./sync.zod.ts | Simple Sync}
 *
 * **When to upgrade:**
 * - Need full connector lifecycle (auth, webhooks, rate limits) → Use {@link file://../integration/connector.zod.ts | Enterprise Connector}
 *
 * @see {@link file://./sync.zod.ts} for Level 1 (simple sync)
 * @see {@link file://../integration/connector.zod.ts} for Level 3 (enterprise integration)
 *
 * ## Use Cases
 *
 * 1. **Data Warehouse Population**
 *    - Extract from multiple operational systems
 *    - Transform to analytical schema
 *    - Load into data warehouse
 *
 * 2. **System Integration**
 *    - Sync data between CRM and Marketing Automation
 *    - Keep product catalog synchronized across e-commerce platforms
 *    - Replicate data for backup/disaster recovery
 *
 * 3. **Data Migration**
 *    - Move data from legacy systems to modern platforms
 *    - Consolidate data from multiple sources
 *    - Split monolithic databases into microservices
 *
 * @see https://airbyte.com/
 * @see https://docs.fivetran.com/
 * @see https://nifi.apache.org/
 *
 * @example
 * ```typescript
 * const salesforceToDB: ETLPipeline = {
 *   name: 'salesforce_to_postgres',
 *   label: 'Salesforce Accounts to PostgreSQL',
 *   source: {
 *     type: 'api',
 *     connector: 'salesforce',
 *     config: { object: 'Account' }
 *   },
 *   destination: {
 *     type: 'database',
 *     connector: 'postgres',
 *     config: { table: 'accounts' }
 *   },
 *   transformations: [
 *     { type: 'map', config: { 'Name': 'account_name' } }
 *   ],
 *   schedule: '0 2 * * *' // Daily at 2 AM
 * }
 * ```
 */
/**
 * ETL Source/Destination Type
 */
declare const ETLEndpointTypeSchema: z.ZodEnum<{
    object: "object";
    file: "file";
    database: "database";
    api: "api";
    storage: "storage";
    stream: "stream";
    warehouse: "warehouse";
    spreadsheet: "spreadsheet";
}>;
type ETLEndpointType = z.infer<typeof ETLEndpointTypeSchema>;
/**
 * ETL Source Configuration
 */
declare const ETLSourceSchema: z.ZodObject<{
    type: z.ZodEnum<{
        object: "object";
        file: "file";
        database: "database";
        api: "api";
        storage: "storage";
        stream: "stream";
        warehouse: "warehouse";
        spreadsheet: "spreadsheet";
    }>;
    connector: z.ZodOptional<z.ZodString>;
    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    incremental: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        cursorField: z.ZodString;
        cursorValue: z.ZodOptional<z.ZodUnknown>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ETLSource = z.infer<typeof ETLSourceSchema>;
/**
 * ETL Destination Configuration
 */
declare const ETLDestinationSchema: z.ZodObject<{
    type: z.ZodEnum<{
        object: "object";
        file: "file";
        database: "database";
        api: "api";
        storage: "storage";
        stream: "stream";
        warehouse: "warehouse";
        spreadsheet: "spreadsheet";
    }>;
    connector: z.ZodOptional<z.ZodString>;
    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    writeMode: z.ZodDefault<z.ZodEnum<{
        upsert: "upsert";
        append: "append";
        merge: "merge";
        overwrite: "overwrite";
    }>>;
    primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type ETLDestination = z.infer<typeof ETLDestinationSchema>;
/**
 * ETL Transformation Type
 */
declare const ETLTransformationTypeSchema: z.ZodEnum<{
    lookup: "lookup";
    map: "map";
    join: "join";
    filter: "filter";
    split: "split";
    normalize: "normalize";
    script: "script";
    aggregate: "aggregate";
    merge: "merge";
    deduplicate: "deduplicate";
}>;
type ETLTransformationType = z.infer<typeof ETLTransformationTypeSchema>;
/**
 * ETL Transformation Configuration
 */
declare const ETLTransformationSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<{
        lookup: "lookup";
        map: "map";
        join: "join";
        filter: "filter";
        split: "split";
        normalize: "normalize";
        script: "script";
        aggregate: "aggregate";
        merge: "merge";
        deduplicate: "deduplicate";
    }>;
    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    continueOnError: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
type ETLTransformation = z.infer<typeof ETLTransformationSchema>;
/**
 * ETL Sync Mode
 */
declare const ETLSyncModeSchema: z.ZodEnum<{
    full: "full";
    cdc: "cdc";
    incremental: "incremental";
}>;
type ETLSyncMode = z.infer<typeof ETLSyncModeSchema>;
/**
 * ETL Pipeline Schema
 *
 * Complete definition of a data pipeline from source to destination with transformations.
 */
declare const ETLPipelineSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    source: z.ZodObject<{
        type: z.ZodEnum<{
            object: "object";
            file: "file";
            database: "database";
            api: "api";
            storage: "storage";
            stream: "stream";
            warehouse: "warehouse";
            spreadsheet: "spreadsheet";
        }>;
        connector: z.ZodOptional<z.ZodString>;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        incremental: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            cursorField: z.ZodString;
            cursorValue: z.ZodOptional<z.ZodUnknown>;
        }, z.core.$strip>>;
    }, z.core.$strip>;
    destination: z.ZodObject<{
        type: z.ZodEnum<{
            object: "object";
            file: "file";
            database: "database";
            api: "api";
            storage: "storage";
            stream: "stream";
            warehouse: "warehouse";
            spreadsheet: "spreadsheet";
        }>;
        connector: z.ZodOptional<z.ZodString>;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        writeMode: z.ZodDefault<z.ZodEnum<{
            upsert: "upsert";
            append: "append";
            merge: "merge";
            overwrite: "overwrite";
        }>>;
        primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>;
    transformations: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        type: z.ZodEnum<{
            lookup: "lookup";
            map: "map";
            join: "join";
            filter: "filter";
            split: "split";
            normalize: "normalize";
            script: "script";
            aggregate: "aggregate";
            merge: "merge";
            deduplicate: "deduplicate";
        }>;
        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        continueOnError: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>>;
    syncMode: z.ZodDefault<z.ZodEnum<{
        full: "full";
        cdc: "cdc";
        incremental: "incremental";
    }>>;
    schedule: z.ZodOptional<z.ZodString>;
    enabled: z.ZodDefault<z.ZodBoolean>;
    retry: z.ZodOptional<z.ZodObject<{
        maxAttempts: z.ZodDefault<z.ZodNumber>;
        backoffMs: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    notifications: z.ZodOptional<z.ZodObject<{
        onSuccess: z.ZodOptional<z.ZodArray<z.ZodString>>;
        onFailure: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
type ETLPipeline = z.infer<typeof ETLPipelineSchema>;
/**
 * ETL Run Status
 */
declare const ETLRunStatusSchema: z.ZodEnum<{
    timeout: "timeout";
    running: "running";
    failed: "failed";
    cancelled: "cancelled";
    pending: "pending";
    succeeded: "succeeded";
}>;
type ETLRunStatus = z.infer<typeof ETLRunStatusSchema>;
/**
 * ETL Pipeline Run Result
 *
 * Result of a pipeline execution
 */
declare const ETLPipelineRunSchema: z.ZodObject<{
    id: z.ZodString;
    pipelineName: z.ZodString;
    status: z.ZodEnum<{
        timeout: "timeout";
        running: "running";
        failed: "failed";
        cancelled: "cancelled";
        pending: "pending";
        succeeded: "succeeded";
    }>;
    startedAt: z.ZodString;
    completedAt: z.ZodOptional<z.ZodString>;
    durationMs: z.ZodOptional<z.ZodNumber>;
    stats: z.ZodOptional<z.ZodObject<{
        recordsRead: z.ZodDefault<z.ZodNumber>;
        recordsWritten: z.ZodDefault<z.ZodNumber>;
        recordsErrored: z.ZodDefault<z.ZodNumber>;
        bytesProcessed: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    error: z.ZodOptional<z.ZodObject<{
        message: z.ZodString;
        code: z.ZodOptional<z.ZodString>;
        details: z.ZodOptional<z.ZodUnknown>;
    }, z.core.$strip>>;
    logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type ETLPipelineRun = z.infer<typeof ETLPipelineRunSchema>;
/**
 * Helper factory for creating ETL pipelines
 */
declare const ETL: {
    /**
     * Create a simple database-to-database pipeline
     */
    readonly databaseSync: (params: {
        name: string;
        sourceTable: string;
        destTable: string;
        schedule?: string;
    }) => ETLPipeline;
    /**
     * Create an API to database pipeline
     */
    readonly apiToDatabase: (params: {
        name: string;
        apiConnector: string;
        destTable: string;
        schedule?: string;
    }) => ETLPipeline;
};

/**
 * Trigger Registry Protocol
 *
 * Lightweight automation triggers for simple integrations.
 * Inspired by Zapier, n8n, and Workato connector architectures.
 *
 * ## When to use Trigger Registry vs. Integration Connector?
 *
 * **Use `automation/trigger-registry.zod.ts` when:**
 * - Building simple automation triggers (e.g., "when Slack message received, create task")
 * - No complex authentication needed (simple API keys, basic auth)
 * - Lightweight, single-purpose integrations
 * - Quick setup with minimal configuration
 * - Webhook-based or polling triggers for automation workflows
 *
 * **Use `integration/connector.zod.ts` when:**
 * - Building enterprise-grade connectors (e.g., Salesforce, SAP, Oracle)
 * - Complex OAuth2/SAML authentication required
 * - Bidirectional sync with field mapping and transformations
 * - Webhook management and rate limiting required
 * - Full CRUD operations and data synchronization
 *
 * ## Use Cases
 *
 * 1. **Simple Automation Triggers**
 *    - Slack notifications on record updates
 *    - Twilio SMS on workflow events
 *    - SendGrid email templates
 *
 * 2. **Lightweight Operations**
 *    - Single-action integrations (send, notify, log)
 *    - No bidirectional sync required
 *    - Webhook receivers for incoming events
 *
 * 3. **Quick Integrations**
 *    - Payment webhooks (Stripe, PayPal)
 *    - Communication triggers (Twilio, SendGrid, Slack)
 *    - Simple API calls to third-party services
 *
 * @see https://zapier.com/developer/documentation/v2/
 * @see https://docs.n8n.io/integrations/creating-nodes/
 * @see ../../integration/connector.zod.ts for enterprise connectors
 *
 * @example
 * ```typescript
 * const slackNotifier: Connector = {
 *   id: 'slack_notify',
 *   name: 'Slack Notification',
 *   category: 'communication',
 *   authentication: {
 *     type: 'apiKey',
 *     fields: [{ name: 'webhook_url', label: 'Webhook URL', type: 'url' }]
 *   },
 *   operations: [
 *     { id: 'send_message', name: 'Send Message', type: 'action' }
 *   ]
 * }
 * ```
 */
/**
 * Connector Category
 */
declare const ConnectorCategorySchema: z.ZodEnum<{
    database: "database";
    other: "other";
    storage: "storage";
    analytics: "analytics";
    support: "support";
    crm: "crm";
    hr: "hr";
    communication: "communication";
    social: "social";
    payment: "payment";
    marketing: "marketing";
    accounting: "accounting";
    productivity: "productivity";
    ecommerce: "ecommerce";
    devtools: "devtools";
}>;
type ConnectorCategory = z.infer<typeof ConnectorCategorySchema>;
/**
 * Authentication Type
 */
declare const AuthenticationTypeSchema: z.ZodEnum<{
    custom: "custom";
    none: "none";
    oauth2: "oauth2";
    basic: "basic";
    apiKey: "apiKey";
    bearer: "bearer";
    oauth1: "oauth1";
}>;
type AuthenticationType = z.infer<typeof AuthenticationTypeSchema>;
/**
 * Authentication Field Schema
 */
declare const AuthFieldSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    type: z.ZodDefault<z.ZodEnum<{
        text: "text";
        url: "url";
        password: "password";
        select: "select";
    }>>;
    description: z.ZodOptional<z.ZodString>;
    required: z.ZodDefault<z.ZodBoolean>;
    default: z.ZodOptional<z.ZodString>;
    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
        label: z.ZodString;
        value: z.ZodString;
    }, z.core.$strip>>>;
    placeholder: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type AuthField = z.infer<typeof AuthFieldSchema>;
/**
 * OAuth 2.0 Configuration
 */
declare const OAuth2ConfigSchema: z.ZodObject<{
    authorizationUrl: z.ZodString;
    tokenUrl: z.ZodString;
    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
    clientIdField: z.ZodDefault<z.ZodString>;
    clientSecretField: z.ZodDefault<z.ZodString>;
}, z.core.$strip>;
type OAuth2Config = z.infer<typeof OAuth2ConfigSchema>;
/**
 * Authentication Configuration
 */
declare const AuthenticationSchema: z.ZodObject<{
    type: z.ZodEnum<{
        custom: "custom";
        none: "none";
        oauth2: "oauth2";
        basic: "basic";
        apiKey: "apiKey";
        bearer: "bearer";
        oauth1: "oauth1";
    }>;
    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
        type: z.ZodDefault<z.ZodEnum<{
            text: "text";
            url: "url";
            password: "password";
            select: "select";
        }>>;
        description: z.ZodOptional<z.ZodString>;
        required: z.ZodDefault<z.ZodBoolean>;
        default: z.ZodOptional<z.ZodString>;
        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
            label: z.ZodString;
            value: z.ZodString;
        }, z.core.$strip>>>;
        placeholder: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    oauth2: z.ZodOptional<z.ZodObject<{
        authorizationUrl: z.ZodString;
        tokenUrl: z.ZodString;
        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
        clientIdField: z.ZodDefault<z.ZodString>;
        clientSecretField: z.ZodDefault<z.ZodString>;
    }, z.core.$strip>>;
    test: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodString>;
        method: z.ZodDefault<z.ZodEnum<{
            GET: "GET";
            POST: "POST";
            PUT: "PUT";
            DELETE: "DELETE";
        }>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Authentication = z.infer<typeof AuthenticationSchema>;
/**
 * Connector Operation Type
 */
declare const OperationTypeSchema: z.ZodEnum<{
    delete: "delete";
    search: "search";
    read: "read";
    write: "write";
    action: "action";
    trigger: "trigger";
}>;
type OperationType = z.infer<typeof OperationTypeSchema>;
/**
 * Operation Parameter Schema
 */
declare const OperationParameterSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<{
        string: "string";
        number: "number";
        boolean: "boolean";
        object: "object";
        date: "date";
        file: "file";
        array: "array";
    }>;
    required: z.ZodDefault<z.ZodBoolean>;
    default: z.ZodOptional<z.ZodUnknown>;
    validation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    dynamicOptions: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type OperationParameter = z.infer<typeof OperationParameterSchema>;
/**
 * Connector Operation Schema
 */
declare const ConnectorOperationSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<{
        delete: "delete";
        search: "search";
        read: "read";
        write: "write";
        action: "action";
        trigger: "trigger";
    }>;
    inputSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        type: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            object: "object";
            date: "date";
            file: "file";
            array: "array";
        }>;
        required: z.ZodDefault<z.ZodBoolean>;
        default: z.ZodOptional<z.ZodUnknown>;
        validation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        dynamicOptions: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    sampleOutput: z.ZodOptional<z.ZodUnknown>;
    supportsPagination: z.ZodDefault<z.ZodBoolean>;
    supportsFiltering: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
type ConnectorOperation = z.infer<typeof ConnectorOperationSchema>;
/**
 * Connector Trigger Schema
 *
 * Triggers are special operations that watch for events and initiate workflows.
 */
declare const ConnectorTriggerSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<{
        webhook: "webhook";
        stream: "stream";
        polling: "polling";
    }>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    pollingIntervalMs: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ConnectorTrigger = z.infer<typeof ConnectorTriggerSchema>;
/**
 * Connector Schema
 *
 * Complete definition of a connector to an external system.
 */
declare const ConnectorSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    version: z.ZodOptional<z.ZodString>;
    icon: z.ZodOptional<z.ZodString>;
    category: z.ZodEnum<{
        database: "database";
        other: "other";
        storage: "storage";
        analytics: "analytics";
        support: "support";
        crm: "crm";
        hr: "hr";
        communication: "communication";
        social: "social";
        payment: "payment";
        marketing: "marketing";
        accounting: "accounting";
        productivity: "productivity";
        ecommerce: "ecommerce";
        devtools: "devtools";
    }>;
    baseUrl: z.ZodOptional<z.ZodString>;
    authentication: z.ZodObject<{
        type: z.ZodEnum<{
            custom: "custom";
            none: "none";
            oauth2: "oauth2";
            basic: "basic";
            apiKey: "apiKey";
            bearer: "bearer";
            oauth1: "oauth1";
        }>;
        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            label: z.ZodString;
            type: z.ZodDefault<z.ZodEnum<{
                text: "text";
                url: "url";
                password: "password";
                select: "select";
            }>>;
            description: z.ZodOptional<z.ZodString>;
            required: z.ZodDefault<z.ZodBoolean>;
            default: z.ZodOptional<z.ZodString>;
            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
                label: z.ZodString;
                value: z.ZodString;
            }, z.core.$strip>>>;
            placeholder: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        oauth2: z.ZodOptional<z.ZodObject<{
            authorizationUrl: z.ZodString;
            tokenUrl: z.ZodString;
            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
            clientIdField: z.ZodDefault<z.ZodString>;
            clientSecretField: z.ZodDefault<z.ZodString>;
        }, z.core.$strip>>;
        test: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodString>;
            method: z.ZodDefault<z.ZodEnum<{
                GET: "GET";
                POST: "POST";
                PUT: "PUT";
                DELETE: "DELETE";
            }>>;
        }, z.core.$strip>>;
    }, z.core.$strip>;
    operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        type: z.ZodEnum<{
            delete: "delete";
            search: "search";
            read: "read";
            write: "write";
            action: "action";
            trigger: "trigger";
        }>;
        inputSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            label: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            type: z.ZodEnum<{
                string: "string";
                number: "number";
                boolean: "boolean";
                object: "object";
                date: "date";
                file: "file";
                array: "array";
            }>;
            required: z.ZodDefault<z.ZodBoolean>;
            default: z.ZodOptional<z.ZodUnknown>;
            validation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            dynamicOptions: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        sampleOutput: z.ZodOptional<z.ZodUnknown>;
        supportsPagination: z.ZodDefault<z.ZodBoolean>;
        supportsFiltering: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>>;
    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        type: z.ZodEnum<{
            webhook: "webhook";
            stream: "stream";
            polling: "polling";
        }>;
        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        pollingIntervalMs: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>>;
    rateLimit: z.ZodOptional<z.ZodObject<{
        requestsPerSecond: z.ZodOptional<z.ZodNumber>;
        requestsPerMinute: z.ZodOptional<z.ZodNumber>;
        requestsPerHour: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    author: z.ZodOptional<z.ZodString>;
    documentation: z.ZodOptional<z.ZodString>;
    homepage: z.ZodOptional<z.ZodString>;
    license: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    verified: z.ZodDefault<z.ZodBoolean>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
/**
 * Connector Instance Schema
 *
 * A configured instance of a connector with credentials.
 */
declare const ConnectorInstanceSchema: z.ZodObject<{
    id: z.ZodString;
    connectorId: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    credentials: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    active: z.ZodDefault<z.ZodBoolean>;
    createdAt: z.ZodOptional<z.ZodString>;
    lastTestedAt: z.ZodOptional<z.ZodString>;
    testStatus: z.ZodDefault<z.ZodEnum<{
        unknown: "unknown";
        success: "success";
        failed: "failed";
    }>>;
}, z.core.$strip>;
type ConnectorInstance = z.infer<typeof ConnectorInstanceSchema>;
type Connector = z.infer<typeof ConnectorSchema>;
/**
 * Helper factory for creating connectors
 */
declare const Connector: {
    /**
     * Create a basic API key connector
     */
    readonly apiKey: (params: {
        id: string;
        name: string;
        category: ConnectorCategory;
        baseUrl: string;
    }) => Connector;
    /**
     * Create an OAuth 2.0 connector
     */
    readonly oauth2: (params: {
        id: string;
        name: string;
        category: ConnectorCategory;
        baseUrl: string;
        authUrl: string;
        tokenUrl: string;
        scopes?: string[];
    }) => Connector;
};

/**
 * Data Sync Protocol - LEVEL 1: Simple Synchronization
 *
 * Inspired by Salesforce Connect, Segment Sync, and Census Reverse ETL.
 *
 * **Positioning in 3-Layer Architecture:**
 * - **L1: Simple Sync** (THIS FILE) - Business users - Sync Salesforce to Sheets
 * - **L2: ETL Pipeline** (automation/etl.zod.ts) - Data engineers - Aggregate 10 sources to warehouse
 * - **L3: Enterprise Connector** (integration/connector.zod.ts) - System integrators - Full SAP integration
 *
 * Data sync provides bidirectional or unidirectional data synchronization
 * between ObjectStack and external systems, maintaining data consistency
 * across platforms.
 *
 * **SCOPE: Simple field mappings only. NO complex transformations.**
 * For complex transformations (joins, aggregates, custom SQL), use ETL Pipeline (Level 2).
 *
 * ## When to Use This Layer
 *
 * **Use Simple Sync when:**
 * - Syncing 1:1 fields between two systems
 * - Simple field transformations (uppercase, cast, etc.)
 * - No complex logic required
 * - Business users need to configure integrations
 *
 * **Examples:**
 * - Salesforce Contact ↔ Google Sheets
 * - HubSpot Company ↔ CRM Account
 * - Shopify Orders → Accounting System
 *
 * **When to upgrade:**
 * - Need multi-source joins → Use {@link file://./etl.zod.ts | ETL Pipeline}
 * - Need complex authentication/webhooks → Use {@link file://../integration/connector.zod.ts | Enterprise Connector}
 * - Need aggregations or data warehousing → Use {@link file://./etl.zod.ts | ETL Pipeline}
 *
 * @see {@link file://./etl.zod.ts} for Level 2 (data engineering)
 * @see {@link file://../integration/connector.zod.ts} for Level 3 (enterprise integration)
 *
 * ## Use Cases
 *
 * 1. **CRM Integration**
 *    - Sync contacts between ObjectStack and Salesforce
 *    - Keep opportunity data synchronized
 *    - Bidirectional updates
 *
 * 2. **Customer Data Platform (CDP)**
 *    - Sync user profiles to Segment
 *    - Enrichment data from Clearbit
 *    - Marketing automation sync
 *
 * 3. **Operational Analytics**
 *    - Sync production data to analytics warehouse
 *    - Real-time dashboards
 *    - Business intelligence
 *
 * @see https://help.salesforce.com/s/articleView?id=sf.platform_connect_about.htm
 * @see https://segment.com/docs/connections/sync/
 * @see https://www.getcensus.com/
 *
 * @example
 * ```typescript
 * const contactSync: DataSyncConfig = {
 *   name: 'salesforce_contact_sync',
 *   label: 'Salesforce Contact Sync',
 *   source: {
 *     object: 'contact',
 *     filters: { status: 'active' }
 *   },
 *   destination: {
 *     connector: 'salesforce',
 *     operation: 'upsert_contact',
 *     mapping: {
 *       first_name: 'FirstName',
 *       last_name: 'LastName',
 *       email: 'Email'
 *     }
 *   },
 *   syncMode: 'incremental',
 *   schedule: '0 * * * *' // Hourly
 * }
 * ```
 */
/**
 * Sync Direction
 */
declare const SyncDirectionSchema: z.ZodEnum<{
    push: "push";
    pull: "pull";
    bidirectional: "bidirectional";
}>;
type SyncDirection = z.infer<typeof SyncDirectionSchema>;
/**
 * Sync Mode
 */
declare const SyncModeSchema: z.ZodEnum<{
    full: "full";
    incremental: "incremental";
    realtime: "realtime";
}>;
type SyncMode = z.infer<typeof SyncModeSchema>;
/**
 * Conflict Resolution Strategy
 */
declare const ConflictResolutionSchema: z.ZodEnum<{
    manual: "manual";
    merge: "merge";
    source_wins: "source_wins";
    destination_wins: "destination_wins";
    latest_wins: "latest_wins";
}>;
type ConflictResolution = z.infer<typeof ConflictResolutionSchema>;
/**
 * Field Mapping for Data Sync
 *
 * Uses the canonical field mapping protocol from shared/mapping.zod.ts
 * for simple 1:1 field transformations.
 *
 * @see {@link FieldMappingSchema} for the base field mapping schema
 */
/**
 * Data Source Configuration
 */
declare const DataSourceConfigSchema: z.ZodObject<{
    object: z.ZodOptional<z.ZodString>;
    filters: z.ZodOptional<z.ZodUnknown>;
    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
    connectorInstanceId: z.ZodOptional<z.ZodString>;
    externalResource: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type DataSourceConfig = z.infer<typeof DataSourceConfigSchema>;
/**
 * Data Destination Configuration
 */
declare const DataDestinationConfigSchema: z.ZodObject<{
    object: z.ZodOptional<z.ZodString>;
    connectorInstanceId: z.ZodOptional<z.ZodString>;
    operation: z.ZodEnum<{
        insert: "insert";
        update: "update";
        delete: "delete";
        upsert: "upsert";
        sync: "sync";
    }>;
    mapping: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodArray<z.ZodObject<{
        source: z.ZodString;
        target: z.ZodString;
        transform: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
            type: z.ZodLiteral<"constant">;
            value: z.ZodUnknown;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"cast">;
            targetType: z.ZodEnum<{
                string: "string";
                number: "number";
                boolean: "boolean";
                date: "date";
            }>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"lookup">;
            table: z.ZodString;
            keyField: z.ZodString;
            valueField: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"javascript">;
            expression: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"map">;
            mappings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strip>], "type">>;
        defaultValue: z.ZodOptional<z.ZodUnknown>;
    }, z.core.$strip>>]>>;
    externalResource: z.ZodOptional<z.ZodString>;
    matchKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type DataDestinationConfig = z.infer<typeof DataDestinationConfigSchema>;
/**
 * Data Sync Configuration Schema
 *
 * Complete definition of a data synchronization between systems.
 */
declare const DataSyncConfigSchema: z.ZodObject<{
    name: z.ZodString;
    label: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    source: z.ZodObject<{
        object: z.ZodOptional<z.ZodString>;
        filters: z.ZodOptional<z.ZodUnknown>;
        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
        connectorInstanceId: z.ZodOptional<z.ZodString>;
        externalResource: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    destination: z.ZodObject<{
        object: z.ZodOptional<z.ZodString>;
        connectorInstanceId: z.ZodOptional<z.ZodString>;
        operation: z.ZodEnum<{
            insert: "insert";
            update: "update";
            delete: "delete";
            upsert: "upsert";
            sync: "sync";
        }>;
        mapping: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodArray<z.ZodObject<{
            source: z.ZodString;
            target: z.ZodString;
            transform: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                type: z.ZodLiteral<"constant">;
                value: z.ZodUnknown;
            }, z.core.$strip>, z.ZodObject<{
                type: z.ZodLiteral<"cast">;
                targetType: z.ZodEnum<{
                    string: "string";
                    number: "number";
                    boolean: "boolean";
                    date: "date";
                }>;
            }, z.core.$strip>, z.ZodObject<{
                type: z.ZodLiteral<"lookup">;
                table: z.ZodString;
                keyField: z.ZodString;
                valueField: z.ZodString;
            }, z.core.$strip>, z.ZodObject<{
                type: z.ZodLiteral<"javascript">;
                expression: z.ZodString;
            }, z.core.$strip>, z.ZodObject<{
                type: z.ZodLiteral<"map">;
                mappings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            }, z.core.$strip>], "type">>;
            defaultValue: z.ZodOptional<z.ZodUnknown>;
        }, z.core.$strip>>]>>;
        externalResource: z.ZodOptional<z.ZodString>;
        matchKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>;
    direction: z.ZodDefault<z.ZodEnum<{
        push: "push";
        pull: "pull";
        bidirectional: "bidirectional";
    }>>;
    syncMode: z.ZodDefault<z.ZodEnum<{
        full: "full";
        incremental: "incremental";
        realtime: "realtime";
    }>>;
    conflictResolution: z.ZodDefault<z.ZodEnum<{
        manual: "manual";
        merge: "merge";
        source_wins: "source_wins";
        destination_wins: "destination_wins";
        latest_wins: "latest_wins";
    }>>;
    schedule: z.ZodOptional<z.ZodString>;
    enabled: z.ZodDefault<z.ZodBoolean>;
    changeTrackingField: z.ZodOptional<z.ZodString>;
    batchSize: z.ZodDefault<z.ZodNumber>;
    retry: z.ZodOptional<z.ZodObject<{
        maxAttempts: z.ZodDefault<z.ZodNumber>;
        backoffMs: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    validation: z.ZodOptional<z.ZodObject<{
        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
        unique: z.ZodOptional<z.ZodArray<z.ZodString>>;
        custom: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            condition: z.ZodString;
            message: z.ZodString;
        }, z.core.$strip>>>;
    }, z.core.$strip>>;
    errorHandling: z.ZodOptional<z.ZodObject<{
        onValidationError: z.ZodDefault<z.ZodEnum<{
            log: "log";
            skip: "skip";
            fail: "fail";
        }>>;
        onSyncError: z.ZodDefault<z.ZodEnum<{
            skip: "skip";
            retry: "retry";
            fail: "fail";
        }>>;
        notifyOnError: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    optimization: z.ZodOptional<z.ZodObject<{
        parallelBatches: z.ZodDefault<z.ZodBoolean>;
        cacheEnabled: z.ZodDefault<z.ZodBoolean>;
        compressionEnabled: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    audit: z.ZodOptional<z.ZodObject<{
        logLevel: z.ZodDefault<z.ZodEnum<{
            error: "error";
            info: "info";
            none: "none";
            warn: "warn";
            debug: "debug";
        }>>;
        retainLogsForDays: z.ZodDefault<z.ZodNumber>;
        trackChanges: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
type DataSyncConfig = z.infer<typeof DataSyncConfigSchema>;
/**
 * Sync Execution Status
 */
declare const SyncExecutionStatusSchema: z.ZodEnum<{
    partial: "partial";
    running: "running";
    completed: "completed";
    failed: "failed";
    cancelled: "cancelled";
    pending: "pending";
}>;
type SyncExecutionStatus = z.infer<typeof SyncExecutionStatusSchema>;
/**
 * Sync Execution Result Schema
 *
 * Result of a sync execution.
 */
declare const SyncExecutionResultSchema: z.ZodObject<{
    id: z.ZodString;
    syncName: z.ZodString;
    status: z.ZodEnum<{
        partial: "partial";
        running: "running";
        completed: "completed";
        failed: "failed";
        cancelled: "cancelled";
        pending: "pending";
    }>;
    startedAt: z.ZodString;
    completedAt: z.ZodOptional<z.ZodString>;
    durationMs: z.ZodOptional<z.ZodNumber>;
    stats: z.ZodOptional<z.ZodObject<{
        recordsProcessed: z.ZodDefault<z.ZodNumber>;
        recordsInserted: z.ZodDefault<z.ZodNumber>;
        recordsUpdated: z.ZodDefault<z.ZodNumber>;
        recordsDeleted: z.ZodDefault<z.ZodNumber>;
        recordsSkipped: z.ZodDefault<z.ZodNumber>;
        recordsErrored: z.ZodDefault<z.ZodNumber>;
        conflictsDetected: z.ZodDefault<z.ZodNumber>;
        conflictsResolved: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
        recordId: z.ZodOptional<z.ZodString>;
        field: z.ZodOptional<z.ZodString>;
        message: z.ZodString;
        code: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type SyncExecutionResult = z.infer<typeof SyncExecutionResultSchema>;
/**
 * Helper factory for creating sync configurations
 */
declare const Sync: {
    /**
     * Create a simple object-to-object sync
     */
    readonly objectSync: (params: {
        name: string;
        sourceObject: string;
        destObject: string;
        mapping: Record<string, string>;
        schedule?: string;
    }) => DataSyncConfig;
    /**
     * Create a connector sync
     */
    readonly connectorSync: (params: {
        name: string;
        sourceObject: string;
        connectorInstanceId: string;
        externalResource: string;
        mapping: Record<string, string>;
        schedule?: string;
    }) => DataSyncConfig;
    /**
     * Create a bidirectional sync
     */
    readonly bidirectionalSync: (params: {
        name: string;
        object: string;
        connectorInstanceId: string;
        externalResource: string;
        mapping: Record<string, string>;
        schedule?: string;
    }) => DataSyncConfig;
};

declare const index_ActionRef: typeof ActionRef;
declare const index_ActionRefSchema: typeof ActionRefSchema;
declare const index_ApprovalActionSchema: typeof ApprovalActionSchema;
declare const index_ApprovalActionType: typeof ApprovalActionType;
type index_ApprovalProcess = ApprovalProcess;
declare const index_ApprovalProcessSchema: typeof ApprovalProcessSchema;
type index_ApprovalStep = ApprovalStep;
declare const index_ApprovalStepSchema: typeof ApprovalStepSchema;
declare const index_ApproverType: typeof ApproverType;
type index_AuthField = AuthField;
declare const index_AuthFieldSchema: typeof AuthFieldSchema;
type index_Authentication = Authentication;
declare const index_AuthenticationSchema: typeof AuthenticationSchema;
type index_AuthenticationType = AuthenticationType;
declare const index_AuthenticationTypeSchema: typeof AuthenticationTypeSchema;
type index_ConflictResolution = ConflictResolution;
declare const index_ConflictResolutionSchema: typeof ConflictResolutionSchema;
declare const index_Connector: typeof Connector;
declare const index_ConnectorActionRefSchema: typeof ConnectorActionRefSchema;
type index_ConnectorCategory = ConnectorCategory;
declare const index_ConnectorCategorySchema: typeof ConnectorCategorySchema;
type index_ConnectorInstance = ConnectorInstance;
declare const index_ConnectorInstanceSchema: typeof ConnectorInstanceSchema;
type index_ConnectorOperation = ConnectorOperation;
declare const index_ConnectorOperationSchema: typeof ConnectorOperationSchema;
declare const index_ConnectorSchema: typeof ConnectorSchema;
type index_ConnectorTrigger = ConnectorTrigger;
declare const index_ConnectorTriggerSchema: typeof ConnectorTriggerSchema;
declare const index_CustomScriptActionSchema: typeof CustomScriptActionSchema;
type index_DataDestinationConfig = DataDestinationConfig;
declare const index_DataDestinationConfigSchema: typeof DataDestinationConfigSchema;
type index_DataSourceConfig = DataSourceConfig;
declare const index_DataSourceConfigSchema: typeof DataSourceConfigSchema;
type index_DataSyncConfig = DataSyncConfig;
declare const index_DataSyncConfigSchema: typeof DataSyncConfigSchema;
declare const index_ETL: typeof ETL;
type index_ETLDestination = ETLDestination;
declare const index_ETLDestinationSchema: typeof ETLDestinationSchema;
type index_ETLEndpointType = ETLEndpointType;
declare const index_ETLEndpointTypeSchema: typeof ETLEndpointTypeSchema;
type index_ETLPipeline = ETLPipeline;
type index_ETLPipelineRun = ETLPipelineRun;
declare const index_ETLPipelineRunSchema: typeof ETLPipelineRunSchema;
declare const index_ETLPipelineSchema: typeof ETLPipelineSchema;
type index_ETLRunStatus = ETLRunStatus;
declare const index_ETLRunStatusSchema: typeof ETLRunStatusSchema;
type index_ETLSource = ETLSource;
declare const index_ETLSourceSchema: typeof ETLSourceSchema;
type index_ETLSyncMode = ETLSyncMode;
declare const index_ETLSyncModeSchema: typeof ETLSyncModeSchema;
type index_ETLTransformation = ETLTransformation;
declare const index_ETLTransformationSchema: typeof ETLTransformationSchema;
type index_ETLTransformationType = ETLTransformationType;
declare const index_ETLTransformationTypeSchema: typeof ETLTransformationTypeSchema;
declare const index_EmailAlertActionSchema: typeof EmailAlertActionSchema;
declare const index_EventSchema: typeof EventSchema;
declare const index_FieldUpdateActionSchema: typeof FieldUpdateActionSchema;
type index_Flow = Flow;
type index_FlowEdge = FlowEdge;
type index_FlowEdgeParsed = FlowEdgeParsed;
declare const index_FlowEdgeSchema: typeof FlowEdgeSchema;
type index_FlowNode = FlowNode;
declare const index_FlowNodeAction: typeof FlowNodeAction;
type index_FlowNodeParsed = FlowNodeParsed;
declare const index_FlowNodeSchema: typeof FlowNodeSchema;
type index_FlowParsed = FlowParsed;
declare const index_FlowSchema: typeof FlowSchema;
declare const index_FlowVariableSchema: typeof FlowVariableSchema;
declare const index_GuardRefSchema: typeof GuardRefSchema;
declare const index_HttpCallActionSchema: typeof HttpCallActionSchema;
type index_OAuth2Config = OAuth2Config;
declare const index_OAuth2ConfigSchema: typeof OAuth2ConfigSchema;
type index_OperationParameter = OperationParameter;
declare const index_OperationParameterSchema: typeof OperationParameterSchema;
type index_OperationType = OperationType;
declare const index_OperationTypeSchema: typeof OperationTypeSchema;
declare const index_PushNotificationActionSchema: typeof PushNotificationActionSchema;
declare const index_StateMachineConfig: typeof StateMachineConfig;
declare const index_StateMachineSchema: typeof StateMachineSchema;
declare const index_StateNodeConfig: typeof StateNodeConfig;
declare const index_StateNodeSchema: typeof StateNodeSchema;
declare const index_Sync: typeof Sync;
type index_SyncDirection = SyncDirection;
declare const index_SyncDirectionSchema: typeof SyncDirectionSchema;
type index_SyncExecutionResult = SyncExecutionResult;
declare const index_SyncExecutionResultSchema: typeof SyncExecutionResultSchema;
type index_SyncExecutionStatus = SyncExecutionStatus;
declare const index_SyncExecutionStatusSchema: typeof SyncExecutionStatusSchema;
type index_SyncMode = SyncMode;
declare const index_SyncModeSchema: typeof SyncModeSchema;
declare const index_TaskCreationActionSchema: typeof TaskCreationActionSchema;
type index_TimeTrigger = TimeTrigger;
declare const index_TimeTriggerSchema: typeof TimeTriggerSchema;
declare const index_Transition: typeof Transition;
declare const index_TransitionSchema: typeof TransitionSchema;
type index_Webhook = Webhook;
type index_WebhookReceiver = WebhookReceiver;
declare const index_WebhookReceiverSchema: typeof WebhookReceiverSchema;
declare const index_WebhookSchema: typeof WebhookSchema;
declare const index_WebhookTriggerType: typeof WebhookTriggerType;
type index_WorkflowAction = WorkflowAction;
declare const index_WorkflowActionSchema: typeof WorkflowActionSchema;
type index_WorkflowRule = WorkflowRule;
declare const index_WorkflowRuleSchema: typeof WorkflowRuleSchema;
declare const index_WorkflowTriggerType: typeof WorkflowTriggerType;
declare const index_defineFlow: typeof defineFlow;
declare namespace index {
  export { index_ActionRef as ActionRef, index_ActionRefSchema as ActionRefSchema, index_ApprovalActionSchema as ApprovalActionSchema, index_ApprovalActionType as ApprovalActionType, type index_ApprovalProcess as ApprovalProcess, index_ApprovalProcessSchema as ApprovalProcessSchema, type index_ApprovalStep as ApprovalStep, index_ApprovalStepSchema as ApprovalStepSchema, index_ApproverType as ApproverType, type index_AuthField as AuthField, index_AuthFieldSchema as AuthFieldSchema, type index_Authentication as Authentication, index_AuthenticationSchema as AuthenticationSchema, type index_AuthenticationType as AuthenticationType, index_AuthenticationTypeSchema as AuthenticationTypeSchema, type index_ConflictResolution as ConflictResolution, index_ConflictResolutionSchema as ConflictResolutionSchema, index_Connector as Connector, index_ConnectorActionRefSchema as ConnectorActionRefSchema, type index_ConnectorCategory as ConnectorCategory, index_ConnectorCategorySchema as ConnectorCategorySchema, type index_ConnectorInstance as ConnectorInstance, index_ConnectorInstanceSchema as ConnectorInstanceSchema, type index_ConnectorOperation as ConnectorOperation, index_ConnectorOperationSchema as ConnectorOperationSchema, index_ConnectorSchema as ConnectorSchema, type index_ConnectorTrigger as ConnectorTrigger, index_ConnectorTriggerSchema as ConnectorTriggerSchema, index_CustomScriptActionSchema as CustomScriptActionSchema, type index_DataDestinationConfig as DataDestinationConfig, index_DataDestinationConfigSchema as DataDestinationConfigSchema, type index_DataSourceConfig as DataSourceConfig, index_DataSourceConfigSchema as DataSourceConfigSchema, type index_DataSyncConfig as DataSyncConfig, index_DataSyncConfigSchema as DataSyncConfigSchema, index_ETL as ETL, type index_ETLDestination as ETLDestination, index_ETLDestinationSchema as ETLDestinationSchema, type index_ETLEndpointType as ETLEndpointType, index_ETLEndpointTypeSchema as ETLEndpointTypeSchema, type index_ETLPipeline as ETLPipeline, type index_ETLPipelineRun as ETLPipelineRun, index_ETLPipelineRunSchema as ETLPipelineRunSchema, index_ETLPipelineSchema as ETLPipelineSchema, type index_ETLRunStatus as ETLRunStatus, index_ETLRunStatusSchema as ETLRunStatusSchema, type index_ETLSource as ETLSource, index_ETLSourceSchema as ETLSourceSchema, type index_ETLSyncMode as ETLSyncMode, index_ETLSyncModeSchema as ETLSyncModeSchema, type index_ETLTransformation as ETLTransformation, index_ETLTransformationSchema as ETLTransformationSchema, type index_ETLTransformationType as ETLTransformationType, index_ETLTransformationTypeSchema as ETLTransformationTypeSchema, index_EmailAlertActionSchema as EmailAlertActionSchema, index_EventSchema as EventSchema, index_FieldUpdateActionSchema as FieldUpdateActionSchema, type index_Flow as Flow, type index_FlowEdge as FlowEdge, type index_FlowEdgeParsed as FlowEdgeParsed, index_FlowEdgeSchema as FlowEdgeSchema, type index_FlowNode as FlowNode, index_FlowNodeAction as FlowNodeAction, type index_FlowNodeParsed as FlowNodeParsed, index_FlowNodeSchema as FlowNodeSchema, type index_FlowParsed as FlowParsed, index_FlowSchema as FlowSchema, index_FlowVariableSchema as FlowVariableSchema, index_GuardRefSchema as GuardRefSchema, index_HttpCallActionSchema as HttpCallActionSchema, type index_OAuth2Config as OAuth2Config, index_OAuth2ConfigSchema as OAuth2ConfigSchema, type index_OperationParameter as OperationParameter, index_OperationParameterSchema as OperationParameterSchema, type index_OperationType as OperationType, index_OperationTypeSchema as OperationTypeSchema, index_PushNotificationActionSchema as PushNotificationActionSchema, index_StateMachineConfig as StateMachineConfig, index_StateMachineSchema as StateMachineSchema, index_StateNodeConfig as StateNodeConfig, index_StateNodeSchema as StateNodeSchema, index_Sync as Sync, type index_SyncDirection as SyncDirection, index_SyncDirectionSchema as SyncDirectionSchema, type index_SyncExecutionResult as SyncExecutionResult, index_SyncExecutionResultSchema as SyncExecutionResultSchema, type index_SyncExecutionStatus as SyncExecutionStatus, index_SyncExecutionStatusSchema as SyncExecutionStatusSchema, type index_SyncMode as SyncMode, index_SyncModeSchema as SyncModeSchema, index_TaskCreationActionSchema as TaskCreationActionSchema, type index_TimeTrigger as TimeTrigger, index_TimeTriggerSchema as TimeTriggerSchema, index_Transition as Transition, index_TransitionSchema as TransitionSchema, type index_Webhook as Webhook, type index_WebhookReceiver as WebhookReceiver, index_WebhookReceiverSchema as WebhookReceiverSchema, index_WebhookSchema as WebhookSchema, index_WebhookTriggerType as WebhookTriggerType, type index_WorkflowAction as WorkflowAction, index_WorkflowActionSchema as WorkflowActionSchema, type index_WorkflowRule as WorkflowRule, index_WorkflowRuleSchema as WorkflowRuleSchema, index_WorkflowTriggerType as WorkflowTriggerType, index_defineFlow as defineFlow };
}

export { ETLRunStatusSchema as $, ApproverType as A, ApprovalActionSchema as B, ConnectorActionRefSchema as C, ApprovalStepSchema as D, EmailAlertActionSchema as E, FieldUpdateActionSchema as F, ApprovalProcessSchema as G, HttpCallActionSchema as H, ApprovalProcess as I, type ApprovalStep as J, ETLEndpointTypeSchema as K, type ETLEndpointType as L, ETLSourceSchema as M, type ETLSource as N, ETLDestinationSchema as O, PushNotificationActionSchema as P, type ETLDestination as Q, ETLTransformationTypeSchema as R, type ETLTransformationType as S, TaskCreationActionSchema as T, ETLTransformationSchema as U, type ETLTransformation as V, WorkflowTriggerType as W, ETLSyncModeSchema as X, type ETLSyncMode as Y, ETLPipelineSchema as Z, type ETLPipeline as _, CustomScriptActionSchema as a, type ETLRunStatus as a0, ETLPipelineRunSchema as a1, type ETLPipelineRun as a2, ETL as a3, ConnectorCategorySchema as a4, type ConnectorCategory as a5, AuthenticationTypeSchema as a6, type AuthenticationType as a7, AuthFieldSchema as a8, type AuthField as a9, DataSyncConfigSchema as aA, type DataSyncConfig as aB, SyncExecutionStatusSchema as aC, type SyncExecutionStatus as aD, SyncExecutionResultSchema as aE, type SyncExecutionResult as aF, Sync as aG, OAuth2ConfigSchema as aa, type OAuth2Config as ab, AuthenticationSchema as ac, type Authentication as ad, OperationTypeSchema as ae, type OperationType as af, OperationParameterSchema as ag, type OperationParameter as ah, ConnectorOperationSchema as ai, type ConnectorOperation as aj, ConnectorTriggerSchema as ak, type ConnectorTrigger as al, ConnectorSchema as am, Connector as an, ConnectorInstanceSchema as ao, type ConnectorInstance as ap, SyncDirectionSchema as aq, type SyncDirection as ar, SyncModeSchema as as, type SyncMode as at, ConflictResolutionSchema as au, type ConflictResolution as av, DataSourceConfigSchema as aw, type DataSourceConfig as ax, DataDestinationConfigSchema as ay, type DataDestinationConfig as az, WorkflowActionSchema as b, type WorkflowAction as c, defineFlow as d, TimeTriggerSchema as e, WorkflowRuleSchema as f, type WorkflowRule as g, type TimeTrigger as h, index as i, FlowNodeAction as j, FlowVariableSchema as k, FlowNodeSchema as l, FlowEdgeSchema as m, FlowSchema as n, type Flow as o, type FlowParsed as p, type FlowNode as q, type FlowNodeParsed as r, type FlowEdge as s, type FlowEdgeParsed as t, WebhookTriggerType as u, WebhookSchema as v, WebhookReceiverSchema as w, type Webhook as x, type WebhookReceiver as y, ApprovalActionType as z };
