@objectstack/spec 0.3.2 → 0.4.1

package/dist/automation/sync.zod.d.ts

@@ -0,0 +1,854 @@
+import { z } from 'zod';
+/**
+ * Data Sync Protocol
+ *
+ * Inspired by Salesforce Connect, Segment Sync, and Census Reverse ETL.
+ *
+ * Data sync provides bidirectional or unidirectional data synchronization
+ * between ObjectStack and external systems, maintaining data consistency
+ * across platforms.
+ *
+ * ## 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
+ */
+export declare const SyncDirectionSchema: z.ZodEnum<["push", "pull", "bidirectional"]>;
+export type SyncDirection = z.infer<typeof SyncDirectionSchema>;
+/**
+ * Sync Mode
+ */
+export declare const SyncModeSchema: z.ZodEnum<["full", "incremental", "realtime"]>;
+export type SyncMode = z.infer<typeof SyncModeSchema>;
+/**
+ * Conflict Resolution Strategy
+ */
+export declare const ConflictResolutionSchema: z.ZodEnum<["source_wins", "destination_wins", "latest_wins", "manual", "merge"]>;
+export type ConflictResolution = z.infer<typeof ConflictResolutionSchema>;
+/**
+ * Field Mapping Schema
+ *
+ * Maps fields between source and destination systems.
+ */
+export declare const FieldMappingSchema: z.ZodObject<{
+    /**
+     * Source field name
+     */
+    sourceField: z.ZodString;
+    /**
+     * Destination field name
+     */
+    destinationField: z.ZodString;
+    /**
+     * Transformation formula
+     * JavaScript expression to transform the value
+     *
+     * @example "value.toUpperCase()"
+     * @example "new Date(value).toISOString()"
+     */
+    transform: z.ZodOptional<z.ZodString>;
+    /**
+     * Default value if source is null/undefined
+     */
+    default: z.ZodOptional<z.ZodAny>;
+    /**
+     * Whether to sync null values
+     */
+    syncNull: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sourceField: string;
+    destinationField: string;
+    syncNull: boolean;
+    default?: any;
+    transform?: string | undefined;
+}, {
+    sourceField: string;
+    destinationField: string;
+    default?: any;
+    transform?: string | undefined;
+    syncNull?: boolean | undefined;
+}>;
+export type FieldMapping = z.infer<typeof FieldMappingSchema>;
+/**
+ * Data Source Configuration
+ */
+export declare const DataSourceConfigSchema: z.ZodObject<{
+    /**
+     * Source object name
+     * For ObjectStack objects
+     */
+    object: z.ZodOptional<z.ZodString>;
+    /**
+     * Filter conditions
+     * Only sync records matching these filters
+     */
+    filters: z.ZodOptional<z.ZodAny>;
+    /**
+     * Fields to include
+     * If not specified, all fields are synced
+     */
+    fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * External connector instance ID
+     * For external data sources
+     */
+    connectorInstanceId: z.ZodOptional<z.ZodString>;
+    /**
+     * External resource identifier
+     * e.g., Salesforce object name, database table, API endpoint
+     */
+    externalResource: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    object?: string | undefined;
+    fields?: string[] | undefined;
+    filters?: any;
+    connectorInstanceId?: string | undefined;
+    externalResource?: string | undefined;
+}, {
+    object?: string | undefined;
+    fields?: string[] | undefined;
+    filters?: any;
+    connectorInstanceId?: string | undefined;
+    externalResource?: string | undefined;
+}>;
+export type DataSourceConfig = z.infer<typeof DataSourceConfigSchema>;
+/**
+ * Data Destination Configuration
+ */
+export declare const DataDestinationConfigSchema: z.ZodObject<{
+    /**
+     * Destination object name
+     * For ObjectStack objects
+     */
+    object: z.ZodOptional<z.ZodString>;
+    /**
+     * Connector instance ID
+     * For external destinations
+     */
+    connectorInstanceId: z.ZodOptional<z.ZodString>;
+    /**
+     * Operation to perform
+     */
+    operation: z.ZodEnum<["insert", "update", "upsert", "delete", "sync"]>;
+    /**
+     * Field mappings
+     * Maps source fields to destination fields
+     */
+    mapping: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodString>, z.ZodArray<z.ZodObject<{
+        /**
+         * Source field name
+         */
+        sourceField: z.ZodString;
+        /**
+         * Destination field name
+         */
+        destinationField: z.ZodString;
+        /**
+         * Transformation formula
+         * JavaScript expression to transform the value
+         *
+         * @example "value.toUpperCase()"
+         * @example "new Date(value).toISOString()"
+         */
+        transform: z.ZodOptional<z.ZodString>;
+        /**
+         * Default value if source is null/undefined
+         */
+        default: z.ZodOptional<z.ZodAny>;
+        /**
+         * Whether to sync null values
+         */
+        syncNull: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        sourceField: string;
+        destinationField: string;
+        syncNull: boolean;
+        default?: any;
+        transform?: string | undefined;
+    }, {
+        sourceField: string;
+        destinationField: string;
+        default?: any;
+        transform?: string | undefined;
+        syncNull?: boolean | undefined;
+    }>, "many">]>>;
+    /**
+     * External resource identifier
+     */
+    externalResource: z.ZodOptional<z.ZodString>;
+    /**
+     * Match key for upsert operations
+     * Fields to use for matching existing records
+     */
+    matchKey: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    operation: "insert" | "update" | "delete" | "upsert" | "sync";
+    object?: string | undefined;
+    mapping?: Record<string, string> | {
+        sourceField: string;
+        destinationField: string;
+        syncNull: boolean;
+        default?: any;
+        transform?: string | undefined;
+    }[] | undefined;
+    connectorInstanceId?: string | undefined;
+    externalResource?: string | undefined;
+    matchKey?: string[] | undefined;
+}, {
+    operation: "insert" | "update" | "delete" | "upsert" | "sync";
+    object?: string | undefined;
+    mapping?: Record<string, string> | {
+        sourceField: string;
+        destinationField: string;
+        default?: any;
+        transform?: string | undefined;
+        syncNull?: boolean | undefined;
+    }[] | undefined;
+    connectorInstanceId?: string | undefined;
+    externalResource?: string | undefined;
+    matchKey?: string[] | undefined;
+}>;
+export type DataDestinationConfig = z.infer<typeof DataDestinationConfigSchema>;
+/**
+ * Data Sync Configuration Schema
+ *
+ * Complete definition of a data synchronization between systems.
+ */
+export declare const DataSyncConfigSchema: z.ZodObject<{
+    /**
+     * Sync configuration name (snake_case)
+     */
+    name: z.ZodString;
+    /**
+     * Human-readable label
+     */
+    label: z.ZodOptional<z.ZodString>;
+    /**
+     * Description
+     */
+    description: z.ZodOptional<z.ZodString>;
+    /**
+     * Source configuration
+     */
+    source: z.ZodObject<{
+        /**
+         * Source object name
+         * For ObjectStack objects
+         */
+        object: z.ZodOptional<z.ZodString>;
+        /**
+         * Filter conditions
+         * Only sync records matching these filters
+         */
+        filters: z.ZodOptional<z.ZodAny>;
+        /**
+         * Fields to include
+         * If not specified, all fields are synced
+         */
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * External connector instance ID
+         * For external data sources
+         */
+        connectorInstanceId: z.ZodOptional<z.ZodString>;
+        /**
+         * External resource identifier
+         * e.g., Salesforce object name, database table, API endpoint
+         */
+        externalResource: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        object?: string | undefined;
+        fields?: string[] | undefined;
+        filters?: any;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+    }, {
+        object?: string | undefined;
+        fields?: string[] | undefined;
+        filters?: any;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+    }>;
+    /**
+     * Destination configuration
+     */
+    destination: z.ZodObject<{
+        /**
+         * Destination object name
+         * For ObjectStack objects
+         */
+        object: z.ZodOptional<z.ZodString>;
+        /**
+         * Connector instance ID
+         * For external destinations
+         */
+        connectorInstanceId: z.ZodOptional<z.ZodString>;
+        /**
+         * Operation to perform
+         */
+        operation: z.ZodEnum<["insert", "update", "upsert", "delete", "sync"]>;
+        /**
+         * Field mappings
+         * Maps source fields to destination fields
+         */
+        mapping: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodString>, z.ZodArray<z.ZodObject<{
+            /**
+             * Source field name
+             */
+            sourceField: z.ZodString;
+            /**
+             * Destination field name
+             */
+            destinationField: z.ZodString;
+            /**
+             * Transformation formula
+             * JavaScript expression to transform the value
+             *
+             * @example "value.toUpperCase()"
+             * @example "new Date(value).toISOString()"
+             */
+            transform: z.ZodOptional<z.ZodString>;
+            /**
+             * Default value if source is null/undefined
+             */
+            default: z.ZodOptional<z.ZodAny>;
+            /**
+             * Whether to sync null values
+             */
+            syncNull: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            sourceField: string;
+            destinationField: string;
+            syncNull: boolean;
+            default?: any;
+            transform?: string | undefined;
+        }, {
+            sourceField: string;
+            destinationField: string;
+            default?: any;
+            transform?: string | undefined;
+            syncNull?: boolean | undefined;
+        }>, "many">]>>;
+        /**
+         * External resource identifier
+         */
+        externalResource: z.ZodOptional<z.ZodString>;
+        /**
+         * Match key for upsert operations
+         * Fields to use for matching existing records
+         */
+        matchKey: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        operation: "insert" | "update" | "delete" | "upsert" | "sync";
+        object?: string | undefined;
+        mapping?: Record<string, string> | {
+            sourceField: string;
+            destinationField: string;
+            syncNull: boolean;
+            default?: any;
+            transform?: string | undefined;
+        }[] | undefined;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+        matchKey?: string[] | undefined;
+    }, {
+        operation: "insert" | "update" | "delete" | "upsert" | "sync";
+        object?: string | undefined;
+        mapping?: Record<string, string> | {
+            sourceField: string;
+            destinationField: string;
+            default?: any;
+            transform?: string | undefined;
+            syncNull?: boolean | undefined;
+        }[] | undefined;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+        matchKey?: string[] | undefined;
+    }>;
+    /**
+     * Sync direction
+     */
+    direction: z.ZodDefault<z.ZodEnum<["push", "pull", "bidirectional"]>>;
+    /**
+     * Sync mode
+     */
+    syncMode: z.ZodDefault<z.ZodEnum<["full", "incremental", "realtime"]>>;
+    /**
+     * Conflict resolution strategy
+     */
+    conflictResolution: z.ZodDefault<z.ZodEnum<["source_wins", "destination_wins", "latest_wins", "manual", "merge"]>>;
+    /**
+     * Execution schedule (cron expression)
+     * For scheduled syncs
+     *
+     * @example "0 * * * *" - Hourly
+     * @example "*\/15 * * * *" - Every 15 minutes
+     */
+    schedule: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether sync is enabled
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Change tracking field
+     * Field to track when records were last modified
+     * Used for incremental sync
+     *
+     * @example "updated_at", "modified_date"
+     */
+    changeTrackingField: z.ZodOptional<z.ZodString>;
+    /**
+     * Batch size
+     * Number of records to process per batch
+     */
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Retry configuration
+     */
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        backoffMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        backoffMs: number;
+        maxAttempts: number;
+    }, {
+        backoffMs?: number | undefined;
+        maxAttempts?: number | undefined;
+    }>>;
+    /**
+     * Pre-sync validation rules
+     */
+    validation: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        unique: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        custom: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            condition: z.ZodString;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            name: string;
+            condition: string;
+        }, {
+            message: string;
+            name: string;
+            condition: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        custom?: {
+            message: string;
+            name: string;
+            condition: string;
+        }[] | undefined;
+        required?: string[] | undefined;
+        unique?: string[] | undefined;
+    }, {
+        custom?: {
+            message: string;
+            name: string;
+            condition: string;
+        }[] | undefined;
+        required?: string[] | undefined;
+        unique?: string[] | undefined;
+    }>>;
+    /**
+     * Error handling configuration
+     */
+    errorHandling: z.ZodOptional<z.ZodObject<{
+        onValidationError: z.ZodDefault<z.ZodEnum<["skip", "fail", "log"]>>;
+        onSyncError: z.ZodDefault<z.ZodEnum<["skip", "fail", "retry"]>>;
+        notifyOnError: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        onValidationError: "log" | "skip" | "fail";
+        onSyncError: "retry" | "skip" | "fail";
+        notifyOnError?: string[] | undefined;
+    }, {
+        onValidationError?: "log" | "skip" | "fail" | undefined;
+        onSyncError?: "retry" | "skip" | "fail" | undefined;
+        notifyOnError?: string[] | undefined;
+    }>>;
+    /**
+     * Performance optimization
+     */
+    optimization: z.ZodOptional<z.ZodObject<{
+        parallelBatches: z.ZodDefault<z.ZodBoolean>;
+        cacheEnabled: z.ZodDefault<z.ZodBoolean>;
+        compressionEnabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        parallelBatches: boolean;
+        cacheEnabled: boolean;
+        compressionEnabled: boolean;
+    }, {
+        parallelBatches?: boolean | undefined;
+        cacheEnabled?: boolean | undefined;
+        compressionEnabled?: boolean | undefined;
+    }>>;
+    /**
+     * Audit and logging
+     */
+    audit: z.ZodOptional<z.ZodObject<{
+        logLevel: z.ZodDefault<z.ZodEnum<["none", "error", "warn", "info", "debug"]>>;
+        retainLogsForDays: z.ZodDefault<z.ZodNumber>;
+        trackChanges: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        logLevel: "error" | "info" | "none" | "debug" | "warn";
+        retainLogsForDays: number;
+        trackChanges: boolean;
+    }, {
+        logLevel?: "error" | "info" | "none" | "debug" | "warn" | undefined;
+        retainLogsForDays?: number | undefined;
+        trackChanges?: boolean | undefined;
+    }>>;
+    /**
+     * Tags for organization
+     */
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Custom metadata
+     */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    enabled: boolean;
+    source: {
+        object?: string | undefined;
+        fields?: string[] | undefined;
+        filters?: any;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+    };
+    batchSize: number;
+    direction: "push" | "pull" | "bidirectional";
+    destination: {
+        operation: "insert" | "update" | "delete" | "upsert" | "sync";
+        object?: string | undefined;
+        mapping?: Record<string, string> | {
+            sourceField: string;
+            destinationField: string;
+            syncNull: boolean;
+            default?: any;
+            transform?: string | undefined;
+        }[] | undefined;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+        matchKey?: string[] | undefined;
+    };
+    syncMode: "full" | "incremental" | "realtime";
+    conflictResolution: "merge" | "manual" | "source_wins" | "destination_wins" | "latest_wins";
+    validation?: {
+        custom?: {
+            message: string;
+            name: string;
+            condition: string;
+        }[] | undefined;
+        required?: string[] | undefined;
+        unique?: string[] | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    schedule?: string | undefined;
+    audit?: {
+        logLevel: "error" | "info" | "none" | "debug" | "warn";
+        retainLogsForDays: number;
+        trackChanges: boolean;
+    } | undefined;
+    retry?: {
+        backoffMs: number;
+        maxAttempts: number;
+    } | undefined;
+    changeTrackingField?: string | undefined;
+    errorHandling?: {
+        onValidationError: "log" | "skip" | "fail";
+        onSyncError: "retry" | "skip" | "fail";
+        notifyOnError?: string[] | undefined;
+    } | undefined;
+    optimization?: {
+        parallelBatches: boolean;
+        cacheEnabled: boolean;
+        compressionEnabled: boolean;
+    } | undefined;
+}, {
+    name: string;
+    source: {
+        object?: string | undefined;
+        fields?: string[] | undefined;
+        filters?: any;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+    };
+    destination: {
+        operation: "insert" | "update" | "delete" | "upsert" | "sync";
+        object?: string | undefined;
+        mapping?: Record<string, string> | {
+            sourceField: string;
+            destinationField: string;
+            default?: any;
+            transform?: string | undefined;
+            syncNull?: boolean | undefined;
+        }[] | undefined;
+        connectorInstanceId?: string | undefined;
+        externalResource?: string | undefined;
+        matchKey?: string[] | undefined;
+    };
+    validation?: {
+        custom?: {
+            message: string;
+            name: string;
+            condition: string;
+        }[] | undefined;
+        required?: string[] | undefined;
+        unique?: string[] | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+    enabled?: boolean | undefined;
+    metadata?: Record<string, any> | undefined;
+    schedule?: string | undefined;
+    audit?: {
+        logLevel?: "error" | "info" | "none" | "debug" | "warn" | undefined;
+        retainLogsForDays?: number | undefined;
+        trackChanges?: boolean | undefined;
+    } | undefined;
+    batchSize?: number | undefined;
+    direction?: "push" | "pull" | "bidirectional" | undefined;
+    syncMode?: "full" | "incremental" | "realtime" | undefined;
+    retry?: {
+        backoffMs?: number | undefined;
+        maxAttempts?: number | undefined;
+    } | undefined;
+    conflictResolution?: "merge" | "manual" | "source_wins" | "destination_wins" | "latest_wins" | undefined;
+    changeTrackingField?: string | undefined;
+    errorHandling?: {
+        onValidationError?: "log" | "skip" | "fail" | undefined;
+        onSyncError?: "retry" | "skip" | "fail" | undefined;
+        notifyOnError?: string[] | undefined;
+    } | undefined;
+    optimization?: {
+        parallelBatches?: boolean | undefined;
+        cacheEnabled?: boolean | undefined;
+        compressionEnabled?: boolean | undefined;
+    } | undefined;
+}>;
+export type DataSyncConfig = z.infer<typeof DataSyncConfigSchema>;
+/**
+ * Sync Execution Status
+ */
+export declare const SyncExecutionStatusSchema: z.ZodEnum<["pending", "running", "completed", "partial", "failed", "cancelled"]>;
+export type SyncExecutionStatus = z.infer<typeof SyncExecutionStatusSchema>;
+/**
+ * Sync Execution Result Schema
+ *
+ * Result of a sync execution.
+ */
+export declare const SyncExecutionResultSchema: z.ZodObject<{
+    /**
+     * Execution ID
+     */
+    id: z.ZodString;
+    /**
+     * Sync configuration name
+     */
+    syncName: z.ZodString;
+    /**
+     * Execution status
+     */
+    status: z.ZodEnum<["pending", "running", "completed", "partial", "failed", "cancelled"]>;
+    /**
+     * Start timestamp
+     */
+    startedAt: z.ZodString;
+    /**
+     * End timestamp
+     */
+    completedAt: z.ZodOptional<z.ZodString>;
+    /**
+     * Duration in milliseconds
+     */
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Statistics
+     */
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        recordsErrored: number;
+        recordsProcessed: number;
+        recordsInserted: number;
+        recordsUpdated: number;
+        recordsDeleted: number;
+        recordsSkipped: number;
+        conflictsDetected: number;
+        conflictsResolved: number;
+    }, {
+        recordsErrored?: number | undefined;
+        recordsProcessed?: number | undefined;
+        recordsInserted?: number | undefined;
+        recordsUpdated?: number | undefined;
+        recordsDeleted?: number | undefined;
+        recordsSkipped?: number | undefined;
+        conflictsDetected?: number | undefined;
+        conflictsResolved?: number | undefined;
+    }>>;
+    /**
+     * Errors encountered
+     */
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code?: string | undefined;
+        field?: string | undefined;
+        recordId?: string | undefined;
+    }, {
+        message: string;
+        code?: string | undefined;
+        field?: string | undefined;
+        recordId?: string | undefined;
+    }>, "many">>;
+    /**
+     * Execution logs
+     */
+    logs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "partial" | "running" | "failed" | "pending" | "completed" | "cancelled";
+    id: string;
+    startedAt: string;
+    syncName: string;
+    durationMs?: number | undefined;
+    completedAt?: string | undefined;
+    logs?: string[] | undefined;
+    errors?: {
+        message: string;
+        code?: string | undefined;
+        field?: string | undefined;
+        recordId?: string | undefined;
+    }[] | undefined;
+    stats?: {
+        recordsErrored: number;
+        recordsProcessed: number;
+        recordsInserted: number;
+        recordsUpdated: number;
+        recordsDeleted: number;
+        recordsSkipped: number;
+        conflictsDetected: number;
+        conflictsResolved: number;
+    } | undefined;
+}, {
+    status: "partial" | "running" | "failed" | "pending" | "completed" | "cancelled";
+    id: string;
+    startedAt: string;
+    syncName: string;
+    durationMs?: number | undefined;
+    completedAt?: string | undefined;
+    logs?: string[] | undefined;
+    errors?: {
+        message: string;
+        code?: string | undefined;
+        field?: string | undefined;
+        recordId?: string | undefined;
+    }[] | undefined;
+    stats?: {
+        recordsErrored?: number | undefined;
+        recordsProcessed?: number | undefined;
+        recordsInserted?: number | undefined;
+        recordsUpdated?: number | undefined;
+        recordsDeleted?: number | undefined;
+        recordsSkipped?: number | undefined;
+        conflictsDetected?: number | undefined;
+        conflictsResolved?: number | undefined;
+    } | undefined;
+}>;
+export type SyncExecutionResult = z.infer<typeof SyncExecutionResultSchema>;
+/**
+ * Helper factory for creating sync configurations
+ */
+export 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;
+};
+//# sourceMappingURL=sync.zod.d.ts.map