@contractspec/example.integration-hub 1.57.0 → 1.58.0

package/dist/node/sync/index.js

@@ -0,0 +1,332 @@
+// 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"
+]);
+
+// 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 }
+  }
+});
+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 }
+  }
+});
+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 }
+  }
+});
+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 }
+  }
+});
+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 }
+  }
+});
+var TriggerSyncInputModel = defineSchemaModel({
+  name: "TriggerSyncInput",
+  fields: {
+    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    direction: { type: SyncDirectionEnum, isOptional: true },
+    fullSync: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+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
+    }
+  }
+});
+var ListSyncRunsOutputModel = defineSchemaModel({
+  name: "ListSyncRunsOutput",
+  fields: {
+    runs: { type: SyncRunModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+
+// src/sync/sync.operations.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+var OWNERS = ["@example.integration-hub"];
+var CreateSyncConfigContract = defineCommand({
+  meta: {
+    key: "integration.syncConfig.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "sync", "config", "create"],
+    description: "Create a sync configuration.",
+    goal: "Define how data should be synchronized.",
+    context: "Sync setup."
+  },
+  io: { input: CreateSyncConfigInputModel, output: SyncConfigModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "integration.syncConfig.created",
+        version: "1.0.0",
+        when: "Sync config created",
+        payload: SyncConfigModel
+      }
+    ],
+    audit: ["integration.syncConfig.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-sync-happy-path",
+        given: ["User is authenticated"],
+        when: ["User creates sync config"],
+        then: ["Sync config is created", "SyncConfigCreated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "create-contact-sync",
+        input: {
+          name: "Contacts Sync",
+          sourceConnectionId: "conn-1",
+          targetConnectionId: "conn-2"
+        },
+        output: { id: "sync-123", status: "active" }
+      }
+    ]
+  }
+});
+var AddFieldMappingContract = defineCommand({
+  meta: {
+    key: "integration.fieldMapping.add",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "mapping", "field"],
+    description: "Add a field mapping to a sync config.",
+    goal: "Map fields between systems.",
+    context: "Mapping configuration."
+  },
+  io: { input: AddFieldMappingInputModel, output: FieldMappingModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "integration.fieldMapping.added",
+        version: "1.0.0",
+        when: "Mapping added",
+        payload: FieldMappingModel
+      }
+    ]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "add-mapping-happy-path",
+        given: ["Sync config exists"],
+        when: ["User adds field mapping"],
+        then: ["Mapping is added", "FieldMappingAdded event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "map-email",
+        input: {
+          syncConfigId: "sync-123",
+          sourceField: "email",
+          targetField: "user_email"
+        },
+        output: { id: "map-456", type: "string" }
+      }
+    ]
+  }
+});
+var TriggerSyncContract = defineCommand({
+  meta: {
+    key: "integration.sync.trigger",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "sync", "trigger"],
+    description: "Trigger a manual sync.",
+    goal: "Start data synchronization.",
+    context: "Manual sync or webhook trigger."
+  },
+  io: { input: TriggerSyncInputModel, output: SyncRunModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "integration.sync.started",
+        version: "1.0.0",
+        when: "Sync starts",
+        payload: SyncRunModel
+      }
+    ],
+    audit: ["integration.sync.triggered"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "trigger-sync-happy-path",
+        given: ["Sync config exists"],
+        when: ["User triggers sync"],
+        then: ["Sync run starts", "SyncStarted event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "manual-trigger",
+        input: { syncConfigId: "sync-123" },
+        output: { id: "run-789", status: "pending" }
+      }
+    ]
+  }
+});
+var ListSyncRunsContract = defineQuery({
+  meta: {
+    key: "integration.syncRun.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "sync", "run", "list"],
+    description: "List sync run history.",
+    goal: "View sync history and status.",
+    context: "Sync monitoring."
+  },
+  io: { input: ListSyncRunsInputModel, output: ListSyncRunsOutputModel },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-runs-happy-path",
+        given: ["User has access to syncs"],
+        when: ["User lists sync runs"],
+        then: ["List of runs is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-recent",
+        input: { limit: 10 },
+        output: { items: [], total: 50 }
+      }
+    ]
+  }
+});
+export {
+  TriggerSyncInputModel,
+  TriggerSyncContract,
+  SyncStatusEnum,
+  SyncRunModel,
+  SyncDirectionEnum,
+  SyncConfigModel,
+  MappingTypeEnum,
+  ListSyncRunsOutputModel,
+  ListSyncRunsInputModel,
+  ListSyncRunsContract,
+  FieldMappingModel,
+  CreateSyncConfigInputModel,
+  CreateSyncConfigContract,
+  AddFieldMappingInputModel,
+  AddFieldMappingContract
+};

package/dist/node/sync/sync.enum.js

@@ -0,0 +1,26 @@
+// 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"
+]);
+export {
+  SyncStatusEnum,
+  SyncDirectionEnum,
+  MappingTypeEnum
+};

package/dist/node/sync/sync.operations.js

@@ -0,0 +1,321 @@
+// 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"
+]);
+
+// 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 }
+  }
+});
+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 }
+  }
+});
+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 }
+  }
+});
+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 }
+  }
+});
+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 }
+  }
+});
+var TriggerSyncInputModel = defineSchemaModel({
+  name: "TriggerSyncInput",
+  fields: {
+    syncConfigId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    direction: { type: SyncDirectionEnum, isOptional: true },
+    fullSync: { type: ScalarTypeEnum.Boolean(), isOptional: true }
+  }
+});
+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
+    }
+  }
+});
+var ListSyncRunsOutputModel = defineSchemaModel({
+  name: "ListSyncRunsOutput",
+  fields: {
+    runs: { type: SyncRunModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+
+// src/sync/sync.operations.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+var OWNERS = ["@example.integration-hub"];
+var CreateSyncConfigContract = defineCommand({
+  meta: {
+    key: "integration.syncConfig.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "sync", "config", "create"],
+    description: "Create a sync configuration.",
+    goal: "Define how data should be synchronized.",
+    context: "Sync setup."
+  },
+  io: { input: CreateSyncConfigInputModel, output: SyncConfigModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "integration.syncConfig.created",
+        version: "1.0.0",
+        when: "Sync config created",
+        payload: SyncConfigModel
+      }
+    ],
+    audit: ["integration.syncConfig.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-sync-happy-path",
+        given: ["User is authenticated"],
+        when: ["User creates sync config"],
+        then: ["Sync config is created", "SyncConfigCreated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "create-contact-sync",
+        input: {
+          name: "Contacts Sync",
+          sourceConnectionId: "conn-1",
+          targetConnectionId: "conn-2"
+        },
+        output: { id: "sync-123", status: "active" }
+      }
+    ]
+  }
+});
+var AddFieldMappingContract = defineCommand({
+  meta: {
+    key: "integration.fieldMapping.add",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "mapping", "field"],
+    description: "Add a field mapping to a sync config.",
+    goal: "Map fields between systems.",
+    context: "Mapping configuration."
+  },
+  io: { input: AddFieldMappingInputModel, output: FieldMappingModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "integration.fieldMapping.added",
+        version: "1.0.0",
+        when: "Mapping added",
+        payload: FieldMappingModel
+      }
+    ]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "add-mapping-happy-path",
+        given: ["Sync config exists"],
+        when: ["User adds field mapping"],
+        then: ["Mapping is added", "FieldMappingAdded event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "map-email",
+        input: {
+          syncConfigId: "sync-123",
+          sourceField: "email",
+          targetField: "user_email"
+        },
+        output: { id: "map-456", type: "string" }
+      }
+    ]
+  }
+});
+var TriggerSyncContract = defineCommand({
+  meta: {
+    key: "integration.sync.trigger",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "sync", "trigger"],
+    description: "Trigger a manual sync.",
+    goal: "Start data synchronization.",
+    context: "Manual sync or webhook trigger."
+  },
+  io: { input: TriggerSyncInputModel, output: SyncRunModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "integration.sync.started",
+        version: "1.0.0",
+        when: "Sync starts",
+        payload: SyncRunModel
+      }
+    ],
+    audit: ["integration.sync.triggered"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "trigger-sync-happy-path",
+        given: ["Sync config exists"],
+        when: ["User triggers sync"],
+        then: ["Sync run starts", "SyncStarted event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "manual-trigger",
+        input: { syncConfigId: "sync-123" },
+        output: { id: "run-789", status: "pending" }
+      }
+    ]
+  }
+});
+var ListSyncRunsContract = defineQuery({
+  meta: {
+    key: "integration.syncRun.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["integration", "sync", "run", "list"],
+    description: "List sync run history.",
+    goal: "View sync history and status.",
+    context: "Sync monitoring."
+  },
+  io: { input: ListSyncRunsInputModel, output: ListSyncRunsOutputModel },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-runs-happy-path",
+        given: ["User has access to syncs"],
+        when: ["User lists sync runs"],
+        then: ["List of runs is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-recent",
+        input: { limit: 10 },
+        output: { items: [], total: 50 }
+      }
+    ]
+  }
+});
+export {
+  TriggerSyncContract,
+  ListSyncRunsContract,
+  CreateSyncConfigContract,
+  AddFieldMappingContract
+};