@contractspec/example.integration-hub 1.57.0 → 1.58.0

package/dist/sync/sync.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync.schema.d.ts","names":[],"sources":["../../src/sync/sync.schema.ts"],"mappings":";;;;;;cAUa,iBAAA,4BAAiB,WAAA;;UAa5B,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKW,eAAA,4BAAe,WAAA;;UAmB1B,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKW,YAAA,4BAAY,WAAA;;UAoBvB,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKW,0BAAA,4BAA0B,WAAA;;UAerC,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKW,yBAAA,4BAAyB,WAAA;;UAgBpC,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKW,qBAAA,4BAAqB,WAAA;;UAOhC,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;cAKW,sBAAA,4BAAsB,WAAA;;UAgBjC,yBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;cAKW,uBAAA,4BAAuB,WAAA;;;;cAMlC,yBAAA,CAAA,SAAA"}
+{"version":3,"file":"sync.schema.d.ts","sourceRoot":"","sources":["../../src/sync/sync.schema.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;EAa5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAerC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;EAOhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAgBjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMlC,CAAC"}

package/dist/sync/sync.schema.js

@@ -1,304 +1,155 @@
-import { MappingTypeEnum, SyncDirectionEnum, SyncStatusEnum } from "./sync.enum.js";
-import { ScalarTypeEnum, defineSchemaModel } from "@contractspec/lib.schema";
+// @bun
+// src/sync/sync.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var SyncDirectionEnum = defineEnum("SyncDirection", [
+  "INBOUND",
+  "OUTBOUND",
+  "BIDIRECTIONAL"
+]);
+var SyncStatusEnum = defineEnum("SyncStatus", [
+  "PENDING",
+  "RUNNING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED"
+]);
+var MappingTypeEnum = defineEnum("MappingType", [
+  "DIRECT",
+  "TRANSFORM",
+  "LOOKUP",
+  "CONSTANT",
+  "COMPUTED"
+]);
 
-//#region src/sync/sync.schema.ts
-/**
-* A field mapping configuration.
-*/
-const FieldMappingModel = defineSchemaModel({
-	name: "FieldMappingModel",
-	fields: {
-		id: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		sourceField: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		targetField: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		mappingType: {
-			type: MappingTypeEnum,
-			isOptional: false
-		},
-		transformExpression: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		},
-		isRequired: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: false
-		}
-	}
+// src/sync/sync.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var FieldMappingModel = defineSchemaModel({
+  name: "FieldMappingModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    sourceField: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    targetField: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    mappingType: { type: MappingTypeEnum, isOptional: false },
+    transformExpression: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    isRequired: { type: ScalarTypeEnum.Boolean(), isOptional: false }
+  }
 });
-/**
-* A sync configuration.
-*/
-const SyncConfigModel = defineSchemaModel({
-	name: "SyncConfigModel",
-	fields: {
-		id: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		integrationId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		connectionId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		name: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		direction: {
-			type: SyncDirectionEnum,
-			isOptional: false
-		},
-		sourceObject: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		targetObject: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		scheduleEnabled: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: false
-		},
-		scheduleCron: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		},
-		isActive: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: false
-		},
-		lastSyncAt: {
-			type: ScalarTypeEnum.DateTime(),
-			isOptional: true
-		},
-		fieldMappings: {
-			type: FieldMappingModel,
-			isArray: true,
-			isOptional: true
-		}
-	}
+var SyncConfigModel = defineSchemaModel({
+  name: "SyncConfigModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    integrationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    connectionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    direction: { type: SyncDirectionEnum, isOptional: false },
+    sourceObject: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    targetObject: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    scheduleEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    scheduleCron: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    lastSyncAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    fieldMappings: { type: FieldMappingModel, isArray: true, isOptional: true }
+  }
 });
-/**
-* A sync run.
-*/
-const SyncRunModel = defineSchemaModel({
-	name: "SyncRunModel",
-	fields: {
-		id: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		syncConfigId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		status: {
-			type: SyncStatusEnum,
-			isOptional: false
-		},
-		direction: {
-			type: SyncDirectionEnum,
-			isOptional: false
-		},
-		trigger: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		recordsProcessed: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: false
-		},
-		recordsCreated: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: false
-		},
-		recordsUpdated: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: false
-		},
-		recordsFailed: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: false
-		},
-		errorMessage: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		},
-		startedAt: {
-			type: ScalarTypeEnum.DateTime(),
-			isOptional: true
-		},
-		completedAt: {
-			type: ScalarTypeEnum.DateTime(),
-			isOptional: true
-		},
-		createdAt: {
-			type: ScalarTypeEnum.DateTime(),
-			isOptional: false
-		}
-	}
+var SyncRunModel = defineSchemaModel({
+  name: "SyncRunModel",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: SyncStatusEnum, isOptional: false },
+    direction: { type: SyncDirectionEnum, isOptional: false },
+    trigger: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    recordsProcessed: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false
+    },
+    recordsCreated: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    recordsUpdated: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    recordsFailed: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
 });
-/**
-* Input for creating a sync config.
-*/
-const CreateSyncConfigInputModel = defineSchemaModel({
-	name: "CreateSyncConfigInput",
-	fields: {
-		integrationId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		connectionId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		name: {
-			type: ScalarTypeEnum.NonEmptyString(),
-			isOptional: false
-		},
-		direction: {
-			type: SyncDirectionEnum,
-			isOptional: false
-		},
-		sourceObject: {
-			type: ScalarTypeEnum.NonEmptyString(),
-			isOptional: false
-		},
-		targetObject: {
-			type: ScalarTypeEnum.NonEmptyString(),
-			isOptional: false
-		},
-		scheduleEnabled: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		},
-		scheduleCron: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		}
-	}
+var CreateSyncConfigInputModel = defineSchemaModel({
+  name: "CreateSyncConfigInput",
+  fields: {
+    integrationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    connectionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    direction: { type: SyncDirectionEnum, isOptional: false },
+    sourceObject: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    targetObject: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    scheduleEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    scheduleCron: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
 });
-/**
-* Input for adding a field mapping.
-*/
-const AddFieldMappingInputModel = defineSchemaModel({
-	name: "AddFieldMappingInput",
-	fields: {
-		syncConfigId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		sourceField: {
-			type: ScalarTypeEnum.NonEmptyString(),
-			isOptional: false
-		},
-		targetField: {
-			type: ScalarTypeEnum.NonEmptyString(),
-			isOptional: false
-		},
-		mappingType: {
-			type: MappingTypeEnum,
-			isOptional: false
-		},
-		transformExpression: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		},
-		lookupConfig: {
-			type: ScalarTypeEnum.JSON(),
-			isOptional: true
-		},
-		constantValue: {
-			type: ScalarTypeEnum.JSON(),
-			isOptional: true
-		},
-		isRequired: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		},
-		defaultValue: {
-			type: ScalarTypeEnum.JSON(),
-			isOptional: true
-		}
-	}
+var AddFieldMappingInputModel = defineSchemaModel({
+  name: "AddFieldMappingInput",
+  fields: {
+    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    sourceField: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    targetField: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    mappingType: { type: MappingTypeEnum, isOptional: false },
+    transformExpression: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    lookupConfig: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    constantValue: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    isRequired: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    defaultValue: { type: ScalarTypeEnum.JSON(), isOptional: true }
+  }
 });
-/**
-* Input for triggering a sync.
-*/
-const TriggerSyncInputModel = defineSchemaModel({
-	name: "TriggerSyncInput",
-	fields: {
-		syncConfigId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		direction: {
-			type: SyncDirectionEnum,
-			isOptional: true
-		},
-		fullSync: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		}
-	}
+var TriggerSyncInputModel = defineSchemaModel({
+  name: "TriggerSyncInput",
+  fields: {
+    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    direction: { type: SyncDirectionEnum, isOptional: true },
+    fullSync: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
 });
-/**
-* Input for listing sync runs.
-*/
-const ListSyncRunsInputModel = defineSchemaModel({
-	name: "ListSyncRunsInput",
-	fields: {
-		syncConfigId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: false
-		},
-		status: {
-			type: SyncStatusEnum,
-			isOptional: true
-		},
-		limit: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: true,
-			defaultValue: 20
-		},
-		offset: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: true,
-			defaultValue: 0
-		}
-	}
+var ListSyncRunsInputModel = defineSchemaModel({
+  name: "ListSyncRunsInput",
+  fields: {
+    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: SyncStatusEnum, isOptional: true },
+    limit: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 20
+    },
+    offset: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 0
+    }
+  }
 });
-/**
-* Output for listing sync runs.
-*/
-const ListSyncRunsOutputModel = defineSchemaModel({
-	name: "ListSyncRunsOutput",
-	fields: {
-		runs: {
-			type: SyncRunModel,
-			isArray: true,
-			isOptional: false
-		},
-		total: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: false
-		}
-	}
+var ListSyncRunsOutputModel = defineSchemaModel({
+  name: "ListSyncRunsOutput",
+  fields: {
+    runs: { type: SyncRunModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
 });
-
-//#endregion
-export { AddFieldMappingInputModel, CreateSyncConfigInputModel, FieldMappingModel, ListSyncRunsInputModel, ListSyncRunsOutputModel, SyncConfigModel, SyncRunModel, TriggerSyncInputModel };
-//# sourceMappingURL=sync.schema.js.map
+export {
+  TriggerSyncInputModel,
+  SyncRunModel,
+  SyncConfigModel,
+  ListSyncRunsOutputModel,
+  ListSyncRunsInputModel,
+  FieldMappingModel,
+  CreateSyncConfigInputModel,
+  AddFieldMappingInputModel
+};

package/dist/sync-engine/index.d.ts

@@ -1,109 +1,106 @@
-//#region src/sync-engine/index.d.ts
 /**
  * Sync Engine
  *
  * Core sync logic for the Integration Hub.
  */
-interface FieldMapping {
-  sourceField: string;
-  targetField: string;
-  mappingType: 'DIRECT' | 'TRANSFORM' | 'LOOKUP' | 'CONSTANT' | 'COMPUTED';
-  transformExpression?: string;
-  lookupConfig?: LookupConfig;
-  constantValue?: unknown;
-  isRequired: boolean;
-  defaultValue?: unknown;
+export interface FieldMapping {
+    sourceField: string;
+    targetField: string;
+    mappingType: 'DIRECT' | 'TRANSFORM' | 'LOOKUP' | 'CONSTANT' | 'COMPUTED';
+    transformExpression?: string;
+    lookupConfig?: LookupConfig;
+    constantValue?: unknown;
+    isRequired: boolean;
+    defaultValue?: unknown;
 }
-interface LookupConfig {
-  sourceObject: string;
-  lookupField: string;
-  returnField: string;
+export interface LookupConfig {
+    sourceObject: string;
+    lookupField: string;
+    returnField: string;
 }
-interface SyncConfig {
-  id: string;
-  direction: 'INBOUND' | 'OUTBOUND' | 'BIDIRECTIONAL';
-  sourceObject: string;
-  targetObject: string;
-  fieldMappings: FieldMapping[];
-  createNew: boolean;
-  updateExisting: boolean;
-  deleteRemoved: boolean;
-  sourceFilter?: Record<string, unknown>;
-}
-interface SyncContext {
-  runId: string;
-  config: SyncConfig;
-  connection: {
+export interface SyncConfig {
     id: string;
-    authType: string;
-    credentials?: Record<string, unknown>;
-  };
+    direction: 'INBOUND' | 'OUTBOUND' | 'BIDIRECTIONAL';
+    sourceObject: string;
+    targetObject: string;
+    fieldMappings: FieldMapping[];
+    createNew: boolean;
+    updateExisting: boolean;
+    deleteRemoved: boolean;
+    sourceFilter?: Record<string, unknown>;
 }
-interface SyncResult {
-  success: boolean;
-  recordsProcessed: number;
-  recordsCreated: number;
-  recordsUpdated: number;
-  recordsDeleted: number;
-  recordsFailed: number;
-  recordsSkipped: number;
-  errors: SyncError[];
+export interface SyncContext {
+    runId: string;
+    config: SyncConfig;
+    connection: {
+        id: string;
+        authType: string;
+        credentials?: Record<string, unknown>;
+    };
 }
-interface SyncError {
-  recordId?: string;
-  field?: string;
-  message: string;
-  code: string;
+export interface SyncResult {
+    success: boolean;
+    recordsProcessed: number;
+    recordsCreated: number;
+    recordsUpdated: number;
+    recordsDeleted: number;
+    recordsFailed: number;
+    recordsSkipped: number;
+    errors: SyncError[];
 }
-interface SourceRecord {
-  id: string;
-  data: Record<string, unknown>;
-  checksum?: string;
+export interface SyncError {
+    recordId?: string;
+    field?: string;
+    message: string;
+    code: string;
 }
-interface TargetRecord {
-  id: string;
-  data: Record<string, unknown>;
-  checksum?: string;
+export interface SourceRecord {
+    id: string;
+    data: Record<string, unknown>;
+    checksum?: string;
 }
-interface ISyncEngine {
-  /**
-   * Execute a sync operation.
-   */
-  sync(context: SyncContext): Promise<SyncResult>;
-  /**
-   * Transform a source record to target format.
-   */
-  transformRecord(sourceRecord: SourceRecord, mappings: FieldMapping[], context: SyncContext): TargetRecord;
-  /**
-   * Validate a transformed record.
-   */
-  validateRecord(record: TargetRecord, mappings: FieldMapping[]): {
-    valid: boolean;
-    errors: SyncError[];
-  };
+export interface TargetRecord {
+    id: string;
+    data: Record<string, unknown>;
+    checksum?: string;
 }
-interface IFieldTransformer {
-  transform(value: unknown, expression: string): unknown;
+export interface ISyncEngine {
+    /**
+     * Execute a sync operation.
+     */
+    sync(context: SyncContext): Promise<SyncResult>;
+    /**
+     * Transform a source record to target format.
+     */
+    transformRecord(sourceRecord: SourceRecord, mappings: FieldMapping[], context: SyncContext): TargetRecord;
+    /**
+     * Validate a transformed record.
+     */
+    validateRecord(record: TargetRecord, mappings: FieldMapping[]): {
+        valid: boolean;
+        errors: SyncError[];
+    };
 }
-declare class BasicFieldTransformer implements IFieldTransformer {
-  transform(value: unknown, expression: string): unknown;
+export interface IFieldTransformer {
+    transform(value: unknown, expression: string): unknown;
 }
-declare class BasicSyncEngine implements ISyncEngine {
-  private transformer;
-  constructor(transformer?: IFieldTransformer);
-  sync(_context: SyncContext): Promise<SyncResult>;
-  transformRecord(sourceRecord: SourceRecord, mappings: FieldMapping[], _context: SyncContext): TargetRecord;
-  validateRecord(record: TargetRecord, mappings: FieldMapping[]): {
-    valid: boolean;
-    errors: SyncError[];
-  };
-  private getNestedValue;
-  private setNestedValue;
-  private evaluateComputed;
+export declare class BasicFieldTransformer implements IFieldTransformer {
+    transform(value: unknown, expression: string): unknown;
+}
+export declare class BasicSyncEngine implements ISyncEngine {
+    private transformer;
+    constructor(transformer?: IFieldTransformer);
+    sync(_context: SyncContext): Promise<SyncResult>;
+    transformRecord(sourceRecord: SourceRecord, mappings: FieldMapping[], _context: SyncContext): TargetRecord;
+    validateRecord(record: TargetRecord, mappings: FieldMapping[]): {
+        valid: boolean;
+        errors: SyncError[];
+    };
+    private getNestedValue;
+    private setNestedValue;
+    private evaluateComputed;
 }
-declare function createSyncEngine(transformer?: IFieldTransformer): ISyncEngine;
-declare function computeChecksum(data: Record<string, unknown>): string;
-declare function hasChanges(sourceChecksum: string | undefined, targetChecksum: string | undefined): boolean;
-//#endregion
-export { BasicFieldTransformer, BasicSyncEngine, FieldMapping, IFieldTransformer, ISyncEngine, LookupConfig, SourceRecord, SyncConfig, SyncContext, SyncError, SyncResult, TargetRecord, computeChecksum, createSyncEngine, hasChanges };
+export declare function createSyncEngine(transformer?: IFieldTransformer): ISyncEngine;
+export declare function computeChecksum(data: Record<string, unknown>): string;
+export declare function hasChanges(sourceChecksum: string | undefined, targetChecksum: string | undefined): boolean;
 //# sourceMappingURL=index.d.ts.map