@memberjunction/server 5.16.0 → 5.17.0

package/dist/resolvers/IntegrationDiscoveryResolver.js

@@ -10,560 +10,3843 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Resolver, Query, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
-import { Metadata, LogError } from "@memberjunction/core";
-import { ConnectorFactory } from "@memberjunction/integration-engine";
-import { SchemaBuilder, TypeMapper } from "@memberjunction/integration-schema-builder";
+var IntegrationDiscoveryResolver_1;
+import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
+import { CompositeKey, Metadata, RunView, LogError } from "@memberjunction/core";
+import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
+import { ConnectorFactory, IntegrationEngine } from "@memberjunction/integration-engine";
+import { SchemaBuilder, TypeMapper, SchemaEvolution } from "@memberjunction/integration-schema-builder";
+import { RuntimeSchemaManager } from "@memberjunction/schema-engine";
 import { ResolverBase } from "../generic/ResolverBase.js";
-// --- Output Types ---
-let ExternalObjectOutput = class ExternalObjectOutput {
+import { UserCache } from "@memberjunction/sqlserver-dataprovider";
+// ─── RSU Pipeline Output Types ──────────────────────────────────────────────
+let RSUStepOutput = class RSUStepOutput {
 };
 __decorate([
     Field(),
     __metadata("design:type", String)
-], ExternalObjectOutput.prototype, "Name", void 0);
+], RSUStepOutput.prototype, "Name", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], ExternalObjectOutput.prototype, "Label", void 0);
+], RSUStepOutput.prototype, "Status", void 0);
 __decorate([
     Field(),
-    __metadata("design:type", Boolean)
-], ExternalObjectOutput.prototype, "SupportsIncrementalSync", void 0);
+    __metadata("design:type", Number)
+], RSUStepOutput.prototype, "DurationMs", void 0);
 __decorate([
     Field(),
-    __metadata("design:type", Boolean)
-], ExternalObjectOutput.prototype, "SupportsWrite", void 0);
-ExternalObjectOutput = __decorate([
+    __metadata("design:type", String)
+], RSUStepOutput.prototype, "Message", void 0);
+RSUStepOutput = __decorate([
     ObjectType()
-], ExternalObjectOutput);
-let DiscoverObjectsOutput = class DiscoverObjectsOutput {
+], RSUStepOutput);
+let ApplySchemaOutput = class ApplySchemaOutput {
 };
 __decorate([
     Field(),
     __metadata("design:type", Boolean)
-], DiscoverObjectsOutput.prototype, "Success", void 0);
+], ApplySchemaOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], DiscoverObjectsOutput.prototype, "Message", void 0);
+], ApplySchemaOutput.prototype, "Message", void 0);
 __decorate([
-    Field(() => [ExternalObjectOutput], { nullable: true }),
+    Field(() => [RSUStepOutput], { nullable: true }),
     __metadata("design:type", Array)
-], DiscoverObjectsOutput.prototype, "Objects", void 0);
-DiscoverObjectsOutput = __decorate([
+], ApplySchemaOutput.prototype, "Steps", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ApplySchemaOutput.prototype, "MigrationFilePath", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], ApplySchemaOutput.prototype, "EntitiesProcessed", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ApplySchemaOutput.prototype, "GitCommitSuccess", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ApplySchemaOutput.prototype, "APIRestarted", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], ApplySchemaOutput.prototype, "Warnings", void 0);
+ApplySchemaOutput = __decorate([
     ObjectType()
-], DiscoverObjectsOutput);
-let ExternalFieldOutput = class ExternalFieldOutput {
+], ApplySchemaOutput);
+let ApplySchemaBatchItemInput = class ApplySchemaBatchItemInput {
 };
 __decorate([
     Field(),
     __metadata("design:type", String)
-], ExternalFieldOutput.prototype, "Name", void 0);
+], ApplySchemaBatchItemInput.prototype, "CompanyIntegrationID", void 0);
 __decorate([
-    Field(),
+    Field(() => [SchemaPreviewObjectInput]),
+    __metadata("design:type", Array)
+], ApplySchemaBatchItemInput.prototype, "Objects", void 0);
+ApplySchemaBatchItemInput = __decorate([
+    InputType()
+], ApplySchemaBatchItemInput);
+// ─── Apply All Input/Output Types ───────────────────────────────────────────
+let SourceObjectInput = class SourceObjectInput {
+};
+__decorate([
+    Field({ description: 'Source object ID (IntegrationObject.ID)' }),
     __metadata("design:type", String)
-], ExternalFieldOutput.prototype, "Label", void 0);
+], SourceObjectInput.prototype, "SourceObjectID", void 0);
+__decorate([
+    Field(() => [String], { nullable: true, description: 'Optional field selection. Empty/null = all fields (including any new ones). Only specified fields get field maps.' }),
+    __metadata("design:type", Array)
+], SourceObjectInput.prototype, "Fields", void 0);
+SourceObjectInput = __decorate([
+    InputType()
+], SourceObjectInput);
+let ApplyAllInput = class ApplyAllInput {
+};
 __decorate([
     Field(),
     __metadata("design:type", String)
-], ExternalFieldOutput.prototype, "DataType", void 0);
+], ApplyAllInput.prototype, "CompanyIntegrationID", void 0);
 __decorate([
-    Field(),
-    __metadata("design:type", Boolean)
-], ExternalFieldOutput.prototype, "IsRequired", void 0);
+    Field(() => [SourceObjectInput]),
+    __metadata("design:type", Array)
+], ApplyAllInput.prototype, "SourceObjects", void 0);
 __decorate([
-    Field(),
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ApplyAllInput.prototype, "CronExpression", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ApplyAllInput.prototype, "ScheduleTimezone", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true, defaultValue: true, description: 'If false, skips the sync step after schema + entity maps are created' }),
     __metadata("design:type", Boolean)
-], ExternalFieldOutput.prototype, "IsUniqueKey", void 0);
+], ApplyAllInput.prototype, "StartSync", void 0);
 __decorate([
-    Field(),
+    Field(() => Boolean, { nullable: true, defaultValue: false, description: 'If true, ignores watermarks and does a full re-fetch' }),
     __metadata("design:type", Boolean)
-], ExternalFieldOutput.prototype, "IsReadOnly", void 0);
-ExternalFieldOutput = __decorate([
-    ObjectType()
-], ExternalFieldOutput);
-let DiscoverFieldsOutput = class DiscoverFieldsOutput {
+], ApplyAllInput.prototype, "FullSync", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 'created', description: 'Sync scope: "created" = only newly created entity maps, "all" = all maps for the connector' }),
+    __metadata("design:type", String)
+], ApplyAllInput.prototype, "SyncScope", void 0);
+ApplyAllInput = __decorate([
+    InputType()
+], ApplyAllInput);
+let ApplyAllEntityMapCreated = class ApplyAllEntityMapCreated {
 };
 __decorate([
     Field(),
-    __metadata("design:type", Boolean)
-], DiscoverFieldsOutput.prototype, "Success", void 0);
+    __metadata("design:type", String)
+], ApplyAllEntityMapCreated.prototype, "SourceObjectName", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], DiscoverFieldsOutput.prototype, "Message", void 0);
+], ApplyAllEntityMapCreated.prototype, "EntityName", void 0);
 __decorate([
-    Field(() => [ExternalFieldOutput], { nullable: true }),
-    __metadata("design:type", Array)
-], DiscoverFieldsOutput.prototype, "Fields", void 0);
-DiscoverFieldsOutput = __decorate([
+    Field(),
+    __metadata("design:type", String)
+], ApplyAllEntityMapCreated.prototype, "EntityMapID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], ApplyAllEntityMapCreated.prototype, "FieldMapCount", void 0);
+ApplyAllEntityMapCreated = __decorate([
     ObjectType()
-], DiscoverFieldsOutput);
-let ConnectionTestOutput = class ConnectionTestOutput {
+], ApplyAllEntityMapCreated);
+let ApplyAllOutput = class ApplyAllOutput {
 };
 __decorate([
     Field(),
     __metadata("design:type", Boolean)
-], ConnectionTestOutput.prototype, "Success", void 0);
+], ApplyAllOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], ConnectionTestOutput.prototype, "Message", void 0);
+], ApplyAllOutput.prototype, "Message", void 0);
 __decorate([
-    Field(() => String, { nullable: true }),
+    Field(() => [RSUStepOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], ApplyAllOutput.prototype, "Steps", void 0);
+__decorate([
+    Field(() => [ApplyAllEntityMapCreated], { nullable: true }),
+    __metadata("design:type", Array)
+], ApplyAllOutput.prototype, "EntityMapsCreated", void 0);
+__decorate([
+    Field({ nullable: true }),
     __metadata("design:type", String)
-], ConnectionTestOutput.prototype, "ServerVersion", void 0);
-ConnectionTestOutput = __decorate([
-    ObjectType()
-], ConnectionTestOutput);
-// --- Preview Data Types ---
-let PreviewRecordOutput = class PreviewRecordOutput {
-};
+], ApplyAllOutput.prototype, "SyncRunID", void 0);
 __decorate([
-    Field(() => String),
+    Field({ nullable: true }),
     __metadata("design:type", String)
-], PreviewRecordOutput.prototype, "Data", void 0);
-PreviewRecordOutput = __decorate([
+], ApplyAllOutput.prototype, "ScheduledJobID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ApplyAllOutput.prototype, "GitCommitSuccess", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ApplyAllOutput.prototype, "APIRestarted", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], ApplyAllOutput.prototype, "Warnings", void 0);
+ApplyAllOutput = __decorate([
     ObjectType()
-], PreviewRecordOutput);
-let PreviewDataOutput = class PreviewDataOutput {
+], ApplyAllOutput);
+let ApplySchemaBatchItemOutput = class ApplySchemaBatchItemOutput {
 };
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ApplySchemaBatchItemOutput.prototype, "CompanyIntegrationID", void 0);
 __decorate([
     Field(),
     __metadata("design:type", Boolean)
-], PreviewDataOutput.prototype, "Success", void 0);
+], ApplySchemaBatchItemOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], PreviewDataOutput.prototype, "Message", void 0);
+], ApplySchemaBatchItemOutput.prototype, "Message", void 0);
 __decorate([
-    Field(() => [PreviewRecordOutput], { nullable: true }),
+    Field(() => [String], { nullable: true }),
     __metadata("design:type", Array)
-], PreviewDataOutput.prototype, "Records", void 0);
-PreviewDataOutput = __decorate([
+], ApplySchemaBatchItemOutput.prototype, "Warnings", void 0);
+ApplySchemaBatchItemOutput = __decorate([
     ObjectType()
-], PreviewDataOutput);
-// --- Schema Preview Types ---
-let SchemaPreviewObjectInput = class SchemaPreviewObjectInput {
+], ApplySchemaBatchItemOutput);
+let ApplySchemaBatchOutput = class ApplySchemaBatchOutput {
 };
 __decorate([
     Field(),
-    __metadata("design:type", String)
-], SchemaPreviewObjectInput.prototype, "SourceObjectName", void 0);
+    __metadata("design:type", Boolean)
+], ApplySchemaBatchOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], SchemaPreviewObjectInput.prototype, "SchemaName", void 0);
+], ApplySchemaBatchOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [ApplySchemaBatchItemOutput]),
+    __metadata("design:type", Array)
+], ApplySchemaBatchOutput.prototype, "Items", void 0);
+__decorate([
+    Field(() => [RSUStepOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], ApplySchemaBatchOutput.prototype, "Steps", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ApplySchemaBatchOutput.prototype, "GitCommitSuccess", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ApplySchemaBatchOutput.prototype, "APIRestarted", void 0);
+ApplySchemaBatchOutput = __decorate([
+    ObjectType()
+], ApplySchemaBatchOutput);
+// ─── Apply All Batch Input/Output Types ──────────────────────────────────────
+let ApplyAllBatchConnectorInput = class ApplyAllBatchConnectorInput {
+};
 __decorate([
     Field(),
     __metadata("design:type", String)
-], SchemaPreviewObjectInput.prototype, "TableName", void 0);
+], ApplyAllBatchConnectorInput.prototype, "CompanyIntegrationID", void 0);
 __decorate([
-    Field(),
+    Field(() => [SourceObjectInput]),
+    __metadata("design:type", Array)
+], ApplyAllBatchConnectorInput.prototype, "SourceObjects", void 0);
+__decorate([
+    Field({ nullable: true }),
     __metadata("design:type", String)
-], SchemaPreviewObjectInput.prototype, "EntityName", void 0);
-SchemaPreviewObjectInput = __decorate([
+], ApplyAllBatchConnectorInput.prototype, "CronExpression", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ApplyAllBatchConnectorInput.prototype, "ScheduleTimezone", void 0);
+ApplyAllBatchConnectorInput = __decorate([
     InputType()
-], SchemaPreviewObjectInput);
-let SchemaPreviewFileOutput = class SchemaPreviewFileOutput {
+], ApplyAllBatchConnectorInput);
+let ApplyAllBatchInput = class ApplyAllBatchInput {
 };
 __decorate([
-    Field(),
+    Field(() => [ApplyAllBatchConnectorInput]),
+    __metadata("design:type", Array)
+], ApplyAllBatchInput.prototype, "Connectors", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true, defaultValue: true, description: 'If false, skips sync after schema + entity maps' }),
+    __metadata("design:type", Boolean)
+], ApplyAllBatchInput.prototype, "StartSync", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true, defaultValue: false, description: 'If true, ignores watermarks and does a full re-fetch' }),
+    __metadata("design:type", Boolean)
+], ApplyAllBatchInput.prototype, "FullSync", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 'created', description: 'Sync scope: "created" = only newly created entity maps, "all" = all maps for the connector' }),
     __metadata("design:type", String)
-], SchemaPreviewFileOutput.prototype, "FilePath", void 0);
+], ApplyAllBatchInput.prototype, "SyncScope", void 0);
+ApplyAllBatchInput = __decorate([
+    InputType()
+], ApplyAllBatchInput);
+let ApplyAllBatchConnectorResult = class ApplyAllBatchConnectorResult {
+};
 __decorate([
     Field(),
     __metadata("design:type", String)
-], SchemaPreviewFileOutput.prototype, "Content", void 0);
+], ApplyAllBatchConnectorResult.prototype, "CompanyIntegrationID", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], SchemaPreviewFileOutput.prototype, "Description", void 0);
-SchemaPreviewFileOutput = __decorate([
-    ObjectType()
-], SchemaPreviewFileOutput);
-let SchemaPreviewOutput = class SchemaPreviewOutput {
-};
+], ApplyAllBatchConnectorResult.prototype, "IntegrationName", void 0);
 __decorate([
     Field(),
     __metadata("design:type", Boolean)
-], SchemaPreviewOutput.prototype, "Success", void 0);
+], ApplyAllBatchConnectorResult.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], SchemaPreviewOutput.prototype, "Message", void 0);
+], ApplyAllBatchConnectorResult.prototype, "Message", void 0);
 __decorate([
-    Field(() => [SchemaPreviewFileOutput], { nullable: true }),
+    Field(() => [ApplyAllEntityMapCreated], { nullable: true }),
     __metadata("design:type", Array)
-], SchemaPreviewOutput.prototype, "Files", void 0);
+], ApplyAllBatchConnectorResult.prototype, "EntityMapsCreated", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ApplyAllBatchConnectorResult.prototype, "SyncRunID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ApplyAllBatchConnectorResult.prototype, "ScheduledJobID", void 0);
 __decorate([
     Field(() => [String], { nullable: true }),
     __metadata("design:type", Array)
-], SchemaPreviewOutput.prototype, "Warnings", void 0);
-SchemaPreviewOutput = __decorate([
+], ApplyAllBatchConnectorResult.prototype, "Warnings", void 0);
+ApplyAllBatchConnectorResult = __decorate([
     ObjectType()
-], SchemaPreviewOutput);
-// --- Default Configuration Types ---
-let DefaultFieldMappingOutput = class DefaultFieldMappingOutput {
+], ApplyAllBatchConnectorResult);
+let ApplyAllBatchOutput = class ApplyAllBatchOutput {
 };
 __decorate([
     Field(),
-    __metadata("design:type", String)
-], DefaultFieldMappingOutput.prototype, "SourceFieldName", void 0);
+    __metadata("design:type", Boolean)
+], ApplyAllBatchOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], DefaultFieldMappingOutput.prototype, "DestinationFieldName", void 0);
+], ApplyAllBatchOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [ApplyAllBatchConnectorResult]),
+    __metadata("design:type", Array)
+], ApplyAllBatchOutput.prototype, "ConnectorResults", void 0);
+__decorate([
+    Field(() => [RSUStepOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], ApplyAllBatchOutput.prototype, "PipelineSteps", void 0);
 __decorate([
     Field({ nullable: true }),
     __metadata("design:type", Boolean)
-], DefaultFieldMappingOutput.prototype, "IsKeyField", void 0);
-DefaultFieldMappingOutput = __decorate([
+], ApplyAllBatchOutput.prototype, "GitCommitSuccess", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ApplyAllBatchOutput.prototype, "APIRestarted", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], ApplyAllBatchOutput.prototype, "SuccessCount", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], ApplyAllBatchOutput.prototype, "FailureCount", void 0);
+ApplyAllBatchOutput = __decorate([
     ObjectType()
-], DefaultFieldMappingOutput);
-let DefaultObjectConfigOutput = class DefaultObjectConfigOutput {
+], ApplyAllBatchOutput);
+// ─── Delete Connection Output ────────────────────────────────────────────────
+let DeleteConnectionOutput = class DeleteConnectionOutput {
 };
 __decorate([
     Field(),
-    __metadata("design:type", String)
-], DefaultObjectConfigOutput.prototype, "SourceObjectName", void 0);
+    __metadata("design:type", Boolean)
+], DeleteConnectionOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], DefaultObjectConfigOutput.prototype, "TargetTableName", void 0);
+], DeleteConnectionOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], DeleteConnectionOutput.prototype, "EntityMapsDeleted", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], DeleteConnectionOutput.prototype, "FieldMapsDeleted", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], DeleteConnectionOutput.prototype, "SchedulesDeleted", void 0);
+DeleteConnectionOutput = __decorate([
+    ObjectType()
+], DeleteConnectionOutput);
+// ─── Schema Evolution Output ─────────────────────────────────────────────────
+let SchemaEvolutionOutput = class SchemaEvolutionOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], SchemaEvolutionOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], DefaultObjectConfigOutput.prototype, "TargetEntityName", void 0);
+], SchemaEvolutionOutput.prototype, "Message", void 0);
 __decorate([
     Field(),
     __metadata("design:type", Boolean)
-], DefaultObjectConfigOutput.prototype, "SyncEnabled", void 0);
+], SchemaEvolutionOutput.prototype, "HasChanges", void 0);
 __decorate([
-    Field(() => [DefaultFieldMappingOutput]),
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], SchemaEvolutionOutput.prototype, "AddedColumns", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], SchemaEvolutionOutput.prototype, "ModifiedColumns", void 0);
+__decorate([
+    Field(() => [RSUStepOutput], { nullable: true }),
     __metadata("design:type", Array)
-], DefaultObjectConfigOutput.prototype, "FieldMappings", void 0);
-DefaultObjectConfigOutput = __decorate([
+], SchemaEvolutionOutput.prototype, "Steps", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], SchemaEvolutionOutput.prototype, "GitCommitSuccess", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], SchemaEvolutionOutput.prototype, "APIRestarted", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaEvolutionOutput.prototype, "Warnings", void 0);
+SchemaEvolutionOutput = __decorate([
     ObjectType()
-], DefaultObjectConfigOutput);
-let DefaultConfigOutput = class DefaultConfigOutput {
+], SchemaEvolutionOutput);
+// ─── Connector Capabilities Output Type ─────────────────────────────────────
+let ConnectorCapabilitiesOutput = class ConnectorCapabilitiesOutput {
 };
 __decorate([
     Field(),
     __metadata("design:type", Boolean)
-], DefaultConfigOutput.prototype, "Success", void 0);
+], ConnectorCapabilitiesOutput.prototype, "Success", void 0);
 __decorate([
     Field(),
     __metadata("design:type", String)
-], DefaultConfigOutput.prototype, "Message", void 0);
+], ConnectorCapabilitiesOutput.prototype, "Message", void 0);
 __decorate([
     Field({ nullable: true }),
-    __metadata("design:type", String)
-], DefaultConfigOutput.prototype, "DefaultSchemaName", void 0);
+    __metadata("design:type", Boolean)
+], ConnectorCapabilitiesOutput.prototype, "SupportsGet", void 0);
 __decorate([
-    Field(() => [DefaultObjectConfigOutput], { nullable: true }),
-    __metadata("design:type", Array)
-], DefaultConfigOutput.prototype, "DefaultObjects", void 0);
-DefaultConfigOutput = __decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ConnectorCapabilitiesOutput.prototype, "SupportsCreate", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ConnectorCapabilitiesOutput.prototype, "SupportsUpdate", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ConnectorCapabilitiesOutput.prototype, "SupportsDelete", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], ConnectorCapabilitiesOutput.prototype, "SupportsSearch", void 0);
+ConnectorCapabilitiesOutput = __decorate([
+    ObjectType()
+], ConnectorCapabilitiesOutput);
+// --- Connector Discovery Output Types ---
+let ConnectorInfoOutput = class ConnectorInfoOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectorInfoOutput.prototype, "IntegrationID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectorInfoOutput.prototype, "Name", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ConnectorInfoOutput.prototype, "Description", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ConnectorInfoOutput.prototype, "ClassName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ConnectorInfoOutput.prototype, "IsActive", void 0);
+ConnectorInfoOutput = __decorate([
+    ObjectType()
+], ConnectorInfoOutput);
+let DiscoverConnectorsOutput = class DiscoverConnectorsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], DiscoverConnectorsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DiscoverConnectorsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [ConnectorInfoOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], DiscoverConnectorsOutput.prototype, "Connectors", void 0);
+DiscoverConnectorsOutput = __decorate([
+    ObjectType()
+], DiscoverConnectorsOutput);
+// --- Field Map List Output Types ---
+let FieldMapSummaryOutput = class FieldMapSummaryOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], FieldMapSummaryOutput.prototype, "ID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], FieldMapSummaryOutput.prototype, "EntityMapID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FieldMapSummaryOutput.prototype, "SourceFieldName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FieldMapSummaryOutput.prototype, "DestinationFieldName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FieldMapSummaryOutput.prototype, "Status", void 0);
+FieldMapSummaryOutput = __decorate([
+    ObjectType()
+], FieldMapSummaryOutput);
+let ListFieldMapsOutput = class ListFieldMapsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ListFieldMapsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ListFieldMapsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [FieldMapSummaryOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], ListFieldMapsOutput.prototype, "FieldMaps", void 0);
+ListFieldMapsOutput = __decorate([
+    ObjectType()
+], ListFieldMapsOutput);
+// --- Output Types ---
+let ExternalObjectOutput = class ExternalObjectOutput {
+};
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ExternalObjectOutput.prototype, "ID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ExternalObjectOutput.prototype, "Name", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ExternalObjectOutput.prototype, "Label", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ExternalObjectOutput.prototype, "SupportsIncrementalSync", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ExternalObjectOutput.prototype, "SupportsWrite", void 0);
+ExternalObjectOutput = __decorate([
+    ObjectType()
+], ExternalObjectOutput);
+let DiscoverObjectsOutput = class DiscoverObjectsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], DiscoverObjectsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DiscoverObjectsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [ExternalObjectOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], DiscoverObjectsOutput.prototype, "Objects", void 0);
+DiscoverObjectsOutput = __decorate([
+    ObjectType()
+], DiscoverObjectsOutput);
+let ExternalFieldOutput = class ExternalFieldOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ExternalFieldOutput.prototype, "Name", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ExternalFieldOutput.prototype, "Label", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ExternalFieldOutput.prototype, "DataType", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ExternalFieldOutput.prototype, "IsRequired", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ExternalFieldOutput.prototype, "IsUniqueKey", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ExternalFieldOutput.prototype, "IsReadOnly", void 0);
+ExternalFieldOutput = __decorate([
+    ObjectType()
+], ExternalFieldOutput);
+let DiscoverFieldsOutput = class DiscoverFieldsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], DiscoverFieldsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DiscoverFieldsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [ExternalFieldOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], DiscoverFieldsOutput.prototype, "Fields", void 0);
+DiscoverFieldsOutput = __decorate([
+    ObjectType()
+], DiscoverFieldsOutput);
+let ConnectionTestOutput = class ConnectionTestOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ConnectionTestOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectionTestOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ConnectionTestOutput.prototype, "ServerVersion", void 0);
+ConnectionTestOutput = __decorate([
+    ObjectType()
+], ConnectionTestOutput);
+// --- Preview Data Types ---
+let PreviewRecordOutput = class PreviewRecordOutput {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], PreviewRecordOutput.prototype, "Data", void 0);
+PreviewRecordOutput = __decorate([
+    ObjectType()
+], PreviewRecordOutput);
+let PreviewDataOutput = class PreviewDataOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], PreviewDataOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], PreviewDataOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [PreviewRecordOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], PreviewDataOutput.prototype, "Records", void 0);
+PreviewDataOutput = __decorate([
+    ObjectType()
+], PreviewDataOutput);
+// --- Schema Preview Types ---
+let SchemaPreviewObjectInput = class SchemaPreviewObjectInput {
+};
+__decorate([
+    Field({ nullable: true, description: 'Source object name. Required if SourceObjectID is not provided.' }),
+    __metadata("design:type", String)
+], SchemaPreviewObjectInput.prototype, "SourceObjectName", void 0);
+__decorate([
+    Field({ nullable: true, description: 'Source object ID (IntegrationObject.ID). Takes priority over SourceObjectName when provided.' }),
+    __metadata("design:type", String)
+], SchemaPreviewObjectInput.prototype, "SourceObjectID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SchemaPreviewObjectInput.prototype, "SchemaName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SchemaPreviewObjectInput.prototype, "TableName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SchemaPreviewObjectInput.prototype, "EntityName", void 0);
+__decorate([
+    Field(() => [String], { nullable: true, description: 'Optional field selection. If provided, only these source fields are included. Default = all fields.' }),
+    __metadata("design:type", Array)
+], SchemaPreviewObjectInput.prototype, "Fields", void 0);
+SchemaPreviewObjectInput = __decorate([
+    InputType()
+], SchemaPreviewObjectInput);
+let SchemaPreviewFileOutput = class SchemaPreviewFileOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SchemaPreviewFileOutput.prototype, "FilePath", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SchemaPreviewFileOutput.prototype, "Content", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SchemaPreviewFileOutput.prototype, "Description", void 0);
+SchemaPreviewFileOutput = __decorate([
+    ObjectType()
+], SchemaPreviewFileOutput);
+let SchemaPreviewOutput = class SchemaPreviewOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], SchemaPreviewOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SchemaPreviewOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [SchemaPreviewFileOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaPreviewOutput.prototype, "Files", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaPreviewOutput.prototype, "Warnings", void 0);
+SchemaPreviewOutput = __decorate([
+    ObjectType()
+], SchemaPreviewOutput);
+// --- Default Configuration Types ---
+let DefaultFieldMappingOutput = class DefaultFieldMappingOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DefaultFieldMappingOutput.prototype, "SourceFieldName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DefaultFieldMappingOutput.prototype, "DestinationFieldName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], DefaultFieldMappingOutput.prototype, "IsKeyField", void 0);
+DefaultFieldMappingOutput = __decorate([
+    ObjectType()
+], DefaultFieldMappingOutput);
+let DefaultObjectConfigOutput = class DefaultObjectConfigOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DefaultObjectConfigOutput.prototype, "SourceObjectName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DefaultObjectConfigOutput.prototype, "TargetTableName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DefaultObjectConfigOutput.prototype, "TargetEntityName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], DefaultObjectConfigOutput.prototype, "SyncEnabled", void 0);
+__decorate([
+    Field(() => [DefaultFieldMappingOutput]),
+    __metadata("design:type", Array)
+], DefaultObjectConfigOutput.prototype, "FieldMappings", void 0);
+DefaultObjectConfigOutput = __decorate([
+    ObjectType()
+], DefaultObjectConfigOutput);
+let DefaultConfigOutput = class DefaultConfigOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], DefaultConfigOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], DefaultConfigOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], DefaultConfigOutput.prototype, "DefaultSchemaName", void 0);
+__decorate([
+    Field(() => [DefaultObjectConfigOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], DefaultConfigOutput.prototype, "DefaultObjects", void 0);
+DefaultConfigOutput = __decorate([
     ObjectType()
 ], DefaultConfigOutput);
+// ─── Integration Management Input/Output Types ─────────────────────────────
+let CreateConnectionInput = class CreateConnectionInput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateConnectionInput.prototype, "IntegrationID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateConnectionInput.prototype, "CompanyID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateConnectionInput.prototype, "CredentialTypeID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateConnectionInput.prototype, "CredentialName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateConnectionInput.prototype, "CredentialValues", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateConnectionInput.prototype, "ExternalSystemID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateConnectionInput.prototype, "Configuration", void 0);
+CreateConnectionInput = __decorate([
+    InputType()
+], CreateConnectionInput);
+let CreateConnectionOutput = class CreateConnectionOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], CreateConnectionOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateConnectionOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateConnectionOutput.prototype, "CompanyIntegrationID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateConnectionOutput.prototype, "CredentialID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], CreateConnectionOutput.prototype, "ConnectionTestSuccess", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateConnectionOutput.prototype, "ConnectionTestMessage", void 0);
+CreateConnectionOutput = __decorate([
+    ObjectType()
+], CreateConnectionOutput);
+let MutationResultOutput = class MutationResultOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], MutationResultOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], MutationResultOutput.prototype, "Message", void 0);
+MutationResultOutput = __decorate([
+    ObjectType()
+], MutationResultOutput);
+let FieldMapInput = class FieldMapInput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], FieldMapInput.prototype, "SourceFieldName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], FieldMapInput.prototype, "DestinationFieldName", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: false }),
+    __metadata("design:type", Boolean)
+], FieldMapInput.prototype, "IsKeyField", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: false }),
+    __metadata("design:type", Boolean)
+], FieldMapInput.prototype, "IsRequired", void 0);
+FieldMapInput = __decorate([
+    InputType()
+], FieldMapInput);
+let EntityMapInput = class EntityMapInput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], EntityMapInput.prototype, "ExternalObjectName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapInput.prototype, "EntityName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapInput.prototype, "EntityID", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 'Pull' }),
+    __metadata("design:type", String)
+], EntityMapInput.prototype, "SyncDirection", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 0 }),
+    __metadata("design:type", Number)
+], EntityMapInput.prototype, "Priority", void 0);
+__decorate([
+    Field(() => [FieldMapInput], { nullable: true }),
+    __metadata("design:type", Array)
+], EntityMapInput.prototype, "FieldMaps", void 0);
+EntityMapInput = __decorate([
+    InputType()
+], EntityMapInput);
+let EntityMapCreatedOutput = class EntityMapCreatedOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], EntityMapCreatedOutput.prototype, "EntityMapID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], EntityMapCreatedOutput.prototype, "ExternalObjectName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], EntityMapCreatedOutput.prototype, "FieldMapCount", void 0);
+EntityMapCreatedOutput = __decorate([
+    ObjectType()
+], EntityMapCreatedOutput);
+let CreateEntityMapsOutput = class CreateEntityMapsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], CreateEntityMapsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateEntityMapsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [EntityMapCreatedOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], CreateEntityMapsOutput.prototype, "Created", void 0);
+CreateEntityMapsOutput = __decorate([
+    ObjectType()
+], CreateEntityMapsOutput);
+let StartSyncOutput = class StartSyncOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], StartSyncOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], StartSyncOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], StartSyncOutput.prototype, "RunID", void 0);
+StartSyncOutput = __decorate([
+    ObjectType()
+], StartSyncOutput);
+let CreateScheduleInput = class CreateScheduleInput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateScheduleInput.prototype, "CompanyIntegrationID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateScheduleInput.prototype, "Name", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateScheduleInput.prototype, "CronExpression", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateScheduleInput.prototype, "Timezone", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateScheduleInput.prototype, "Description", void 0);
+CreateScheduleInput = __decorate([
+    InputType()
+], CreateScheduleInput);
+let CreateScheduleOutput = class CreateScheduleOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], CreateScheduleOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateScheduleOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateScheduleOutput.prototype, "ScheduledJobID", void 0);
+CreateScheduleOutput = __decorate([
+    ObjectType()
+], CreateScheduleOutput);
+let ScheduleSummaryOutput = class ScheduleSummaryOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ScheduleSummaryOutput.prototype, "ID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ScheduleSummaryOutput.prototype, "Name", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ScheduleSummaryOutput.prototype, "Status", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ScheduleSummaryOutput.prototype, "CronExpression", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ScheduleSummaryOutput.prototype, "Timezone", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ScheduleSummaryOutput.prototype, "NextRunAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ScheduleSummaryOutput.prototype, "LastRunAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], ScheduleSummaryOutput.prototype, "RunCount", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], ScheduleSummaryOutput.prototype, "SuccessCount", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], ScheduleSummaryOutput.prototype, "FailureCount", void 0);
+ScheduleSummaryOutput = __decorate([
+    ObjectType()
+], ScheduleSummaryOutput);
+let ListSchedulesOutput = class ListSchedulesOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ListSchedulesOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ListSchedulesOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [ScheduleSummaryOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], ListSchedulesOutput.prototype, "Schedules", void 0);
+ListSchedulesOutput = __decorate([
+    ObjectType()
+], ListSchedulesOutput);
+let EntityMapUpdateInput = class EntityMapUpdateInput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], EntityMapUpdateInput.prototype, "EntityMapID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapUpdateInput.prototype, "SyncDirection", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], EntityMapUpdateInput.prototype, "Priority", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapUpdateInput.prototype, "Status", void 0);
+EntityMapUpdateInput = __decorate([
+    InputType()
+], EntityMapUpdateInput);
+let EntityMapSummaryOutput = class EntityMapSummaryOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], EntityMapSummaryOutput.prototype, "ID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapSummaryOutput.prototype, "EntityID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapSummaryOutput.prototype, "Entity", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapSummaryOutput.prototype, "ExternalObjectName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapSummaryOutput.prototype, "SyncDirection", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], EntityMapSummaryOutput.prototype, "Priority", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapSummaryOutput.prototype, "Status", void 0);
+EntityMapSummaryOutput = __decorate([
+    ObjectType()
+], EntityMapSummaryOutput);
+let ListEntityMapsOutput = class ListEntityMapsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ListEntityMapsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ListEntityMapsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [EntityMapSummaryOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], ListEntityMapsOutput.prototype, "EntityMaps", void 0);
+ListEntityMapsOutput = __decorate([
+    ObjectType()
+], ListEntityMapsOutput);
+let IntegrationStatusOutput = class IntegrationStatusOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationStatusOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], IntegrationStatusOutput.prototype, "IsActive", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "IntegrationName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "CompanyIntegrationID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationStatusOutput.prototype, "TotalEntityMaps", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationStatusOutput.prototype, "ActiveEntityMaps", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "LastRunStatus", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "LastRunStartedAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "LastRunEndedAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], IntegrationStatusOutput.prototype, "ScheduleEnabled", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], IntegrationStatusOutput.prototype, "RSUEnabled", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], IntegrationStatusOutput.prototype, "RSURunning", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], IntegrationStatusOutput.prototype, "RSUOutOfSync", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "RSULastRunAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationStatusOutput.prototype, "RSULastRunResult", void 0);
+IntegrationStatusOutput = __decorate([
+    ObjectType()
+], IntegrationStatusOutput);
+let SyncRunEntityDetail = class SyncRunEntityDetail {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SyncRunEntityDetail.prototype, "EntityName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], SyncRunEntityDetail.prototype, "InsertCount", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], SyncRunEntityDetail.prototype, "UpdateCount", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], SyncRunEntityDetail.prototype, "SkipCount", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], SyncRunEntityDetail.prototype, "ErrorCount", void 0);
+SyncRunEntityDetail = __decorate([
+    ObjectType()
+], SyncRunEntityDetail);
+let SyncRunSummaryOutput = class SyncRunSummaryOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SyncRunSummaryOutput.prototype, "ID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SyncRunSummaryOutput.prototype, "Status", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SyncRunSummaryOutput.prototype, "StartedAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SyncRunSummaryOutput.prototype, "EndedAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], SyncRunSummaryOutput.prototype, "TotalRecords", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SyncRunSummaryOutput.prototype, "RunByUserID", void 0);
+__decorate([
+    Field(() => [SyncRunEntityDetail], { nullable: true }),
+    __metadata("design:type", Array)
+], SyncRunSummaryOutput.prototype, "EntityDetails", void 0);
+SyncRunSummaryOutput = __decorate([
+    ObjectType()
+], SyncRunSummaryOutput);
+let SyncHistoryOutput = class SyncHistoryOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], SyncHistoryOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SyncHistoryOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [SyncRunSummaryOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], SyncHistoryOutput.prototype, "Runs", void 0);
+SyncHistoryOutput = __decorate([
+    ObjectType()
+], SyncHistoryOutput);
+let OperationProgressOutput = class OperationProgressOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], OperationProgressOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], OperationProgressOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], OperationProgressOutput.prototype, "OperationType", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], OperationProgressOutput.prototype, "IsRunning", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], OperationProgressOutput.prototype, "CurrentEntity", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "EntityMapsTotal", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "EntityMapsCompleted", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "RecordsProcessed", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "RecordsCreated", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "RecordsUpdated", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "RecordsErrored", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], OperationProgressOutput.prototype, "RSUStep", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], OperationProgressOutput.prototype, "RSURunning", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "ElapsedMs", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], OperationProgressOutput.prototype, "StartedAt", void 0);
+OperationProgressOutput = __decorate([
+    ObjectType()
+], OperationProgressOutput);
+// Sync progress is now tracked inside IntegrationEngine itself via IntegrationEngine.GetSyncProgress()
+let ConnectionSummaryOutput = class ConnectionSummaryOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectionSummaryOutput.prototype, "ID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectionSummaryOutput.prototype, "IntegrationName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectionSummaryOutput.prototype, "IntegrationID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectionSummaryOutput.prototype, "CompanyID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ConnectionSummaryOutput.prototype, "Company", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ConnectionSummaryOutput.prototype, "IsActive", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ConnectionSummaryOutput.prototype, "ScheduleEnabled", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], ConnectionSummaryOutput.prototype, "CronExpression", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ConnectionSummaryOutput.prototype, "CreatedAt", void 0);
+ConnectionSummaryOutput = __decorate([
+    ObjectType()
+], ConnectionSummaryOutput);
+let ListConnectionsOutput = class ListConnectionsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], ListConnectionsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ListConnectionsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [ConnectionSummaryOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], ListConnectionsOutput.prototype, "Connections", void 0);
+ListConnectionsOutput = __decorate([
+    ObjectType()
+], ListConnectionsOutput);
 // --- Resolver ---
+// ── Validation helpers for entity map union types ──────────────────────
+const VALID_SYNC_DIRECTIONS = ['Bidirectional', 'Pull', 'Push'];
+function isValidSyncDirection(value) {
+    return VALID_SYNC_DIRECTIONS.includes(value);
+}
+const VALID_ENTITY_MAP_STATUSES = ['Active', 'Inactive'];
+function isValidEntityMapStatus(value) {
+    return VALID_ENTITY_MAP_STATUSES.includes(value);
+}
 /**
  * GraphQL resolver for integration discovery operations.
  * Provides endpoints to test connections, discover objects, and discover fields
  * on external systems via their registered connectors.
  */
 let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends ResolverBase {
+    static { IntegrationDiscoveryResolver_1 = this; }
+    /**
+     * Lists all registered integration connectors (active by default).
+     * Useful for populating connector selection UIs.
+     */
+    async IntegrationDiscoverConnectors(companyID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: Integrations',
+                ExtraFilter: '',
+                OrderBy: 'Name',
+                ResultType: 'entity_object'
+            }, user);
+            if (!result.Success)
+                return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+            return {
+                Success: true,
+                Message: `${result.Results.length} connectors available`,
+                Connectors: result.Results
+                    .map(r => ({
+                    IntegrationID: r.ID,
+                    Name: r.Name,
+                    Description: r.Description,
+                    ClassName: r.ClassName,
+                    IsActive: true
+                }))
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationDiscoverConnectors error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /**
+     * Discovers available objects/tables in the external system.
+     */
+    async IntegrationDiscoverObjects(companyIntegrationID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+            // Cast through unknown to bridge duplicate package type declarations
+            // (integration-engine resolves its own node_modules copies of core/core-entities)
+            const discoverObjects = connector.DiscoverObjects.bind(connector);
+            const objects = await discoverObjects(companyIntegration, user);
+            return {
+                Success: true,
+                Message: `Discovered ${objects.length} objects`,
+                Objects: objects.map(o => ({
+                    ID: o.ID,
+                    Name: o.Name,
+                    Label: o.Label,
+                    SupportsIncrementalSync: o.SupportsIncrementalSync,
+                    SupportsWrite: o.SupportsWrite
+                }))
+            };
+        }
+        catch (e) {
+            return this.handleDiscoveryError(e);
+        }
+    }
+    /**
+     * Discovers fields on a specific external object.
+     */
+    async IntegrationDiscoverFields(companyIntegrationID, objectName, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+            // Cast through unknown to bridge duplicate package type declarations
+            const discoverFields = connector.DiscoverFields.bind(connector);
+            const fields = await discoverFields(companyIntegration, objectName, user);
+            return {
+                Success: true,
+                Message: `Discovered ${fields.length} fields on "${objectName}"`,
+                Fields: fields.map(f => ({
+                    Name: f.Name,
+                    Label: f.Label,
+                    DataType: f.DataType,
+                    IsRequired: f.IsRequired,
+                    IsUniqueKey: f.IsUniqueKey,
+                    IsReadOnly: f.IsReadOnly
+                }))
+            };
+        }
+        catch (e) {
+            return this.handleDiscoveryError(e);
+        }
+    }
+    /**
+     * Tests connectivity to the external system.
+     */
+    async IntegrationTestConnection(companyIntegrationID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+            // Cast through unknown to bridge duplicate package type declarations
+            const testConnection = connector.TestConnection.bind(connector);
+            const result = await testConnection(companyIntegration, user);
+            return {
+                Success: result.Success,
+                Message: result.Message,
+                ServerVersion: result.ServerVersion
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationTestConnection error: ${this.formatError(e)}`);
+            return {
+                Success: false,
+                Message: `Error: ${this.formatError(e)}`
+            };
+        }
+    }
+    /**
+     * Returns the connector's default configuration for quick setup.
+     * Not all connectors provide defaults — returns Success: false if unavailable.
+     */
+    async IntegrationGetDefaultConfig(companyIntegrationID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector } = await this.resolveConnector(companyIntegrationID, user);
+            const config = connector.GetDefaultConfiguration();
+            if (!config) {
+                return {
+                    Success: false,
+                    Message: 'This connector does not provide a default configuration'
+                };
+            }
+            return {
+                Success: true,
+                Message: `Default configuration with ${config.DefaultObjects.length} objects`,
+                DefaultSchemaName: config.DefaultSchemaName,
+                DefaultObjects: config.DefaultObjects.map(o => ({
+                    SourceObjectName: o.SourceObjectName,
+                    TargetTableName: o.TargetTableName,
+                    TargetEntityName: o.TargetEntityName,
+                    SyncEnabled: o.SyncEnabled,
+                    FieldMappings: o.FieldMappings.map(f => ({
+                        SourceFieldName: f.SourceFieldName,
+                        DestinationFieldName: f.DestinationFieldName,
+                        IsKeyField: f.IsKeyField
+                    }))
+                }))
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationGetDefaultConfig error: ${this.formatError(e)}`);
+            return {
+                Success: false,
+                Message: `Error: ${this.formatError(e)}`
+            };
+        }
+    }
+    /**
+     * Generates a DDL preview for creating tables from discovered external objects.
+     * Introspects the source schema and runs SchemaBuilder to produce migration SQL.
+     */
+    async IntegrationSchemaPreview(companyIntegrationID, objects, platform, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+            // Introspect schema from the external system
+            const introspect = connector.IntrospectSchema.bind(connector);
+            const sourceSchema = await introspect(companyIntegration, user);
+            await this.resolveObjectInputs(objects, sourceSchema, user);
+            const requestedNames = new Set(objects.map(o => o.SourceObjectName));
+            const filteredSchema = {
+                Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
+            };
+            const validatedPlatform = this.validatePlatform(platform);
+            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, validatedPlatform, connector);
+            // Run SchemaBuilder
+            const input = {
+                SourceSchema: filteredSchema,
+                TargetConfigs: targetConfigs,
+                Platform: validatedPlatform,
+                MJVersion: process.env.MJ_VERSION ?? '5.11.0',
+                SourceType: companyIntegration.Integration,
+                AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+                MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+                MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+                ExistingTables: this.buildExistingTables(targetConfigs),
+                EntitySettingsForTargets: {}
+            };
+            const builder = new SchemaBuilder();
+            const output = builder.BuildSchema(input);
+            if (output.Errors.length > 0) {
+                return {
+                    Success: false,
+                    Message: `Schema generation failed: ${output.Errors.join('; ')}`,
+                    Warnings: output.Warnings
+                };
+            }
+            const allFiles = [
+                ...output.MigrationFiles,
+                ...(output.AdditionalSchemaInfoUpdate ? [output.AdditionalSchemaInfoUpdate] : []),
+                ...output.MetadataFiles
+            ];
+            return {
+                Success: true,
+                Message: `Generated ${allFiles.length} files`,
+                Files: allFiles.map(f => ({
+                    FilePath: f.FilePath,
+                    Content: f.Content,
+                    Description: f.Description
+                })),
+                Warnings: output.Warnings.length > 0 ? output.Warnings : undefined
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationSchemaPreview error: ${this.formatError(e)}`);
+            return {
+                Success: false,
+                Message: `Error: ${this.formatError(e)}`
+            };
+        }
+    }
+    /**
+     * Fetches a small sample of records from an external object for preview purposes.
+     * Uses the connector's FetchChanges with a small batch size and no watermark.
+     */
+    async IntegrationPreviewData(companyIntegrationID, objectName, limit, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+            const fetchChanges = connector.FetchChanges.bind(connector);
+            const result = await fetchChanges({
+                CompanyIntegration: companyIntegration,
+                ObjectName: objectName,
+                WatermarkValue: null,
+                BatchSize: Math.min(limit, 10),
+                ContextUser: user
+            });
+            const truncated = result.Records.slice(0, limit);
+            return {
+                Success: true,
+                Message: `Fetched ${truncated.length} preview records${result.Records.length > limit ? ` (truncated from ${result.Records.length})` : ''}`,
+                Records: truncated.map(r => ({
+                    Data: JSON.stringify(r.Fields)
+                }))
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationPreviewData error: ${this.formatError(e)}`);
+            return {
+                Success: false,
+                Message: `Error: ${this.formatError(e)}`
+            };
+        }
+    }
+    // --- Private Helpers ---
+    buildTargetConfigs(objects, sourceSchema, platform, connector) {
+        const mapper = new TypeMapper();
+        // Build a lookup from the connector's static metadata for descriptions.
+        // DB entities may not have Description populated yet on first run,
+        // but the connector's GetIntegrationObjects() always has them.
+        const connectorDescriptions = this.buildDescriptionLookup(connector);
+        return objects.map(obj => {
+            const sourceObj = sourceSchema.Objects.find(o => o.ExternalName.toLowerCase() === obj.SourceObjectName.toLowerCase());
+            const objDescriptions = connectorDescriptions.get(obj.SourceObjectName.toLowerCase());
+            // Filter fields if caller specified a subset
+            const selectedFieldSet = obj.Fields?.length
+                ? new Set(obj.Fields.map(f => f.toLowerCase()))
+                : null;
+            const sourceFields = (sourceObj?.Fields ?? []).filter(f => !selectedFieldSet || selectedFieldSet.has(f.Name.toLowerCase()) || f.IsPrimaryKey);
+            const columns = sourceFields.map(f => ({
+                SourceFieldName: f.Name,
+                TargetColumnName: f.Name.replace(/[^A-Za-z0-9_]/g, '_'),
+                TargetSqlType: mapper.MapSourceType(f.SourceType, platform, f),
+                IsNullable: !f.IsRequired,
+                MaxLength: f.MaxLength,
+                Precision: f.Precision,
+                Scale: f.Scale,
+                DefaultValue: f.DefaultValue,
+                Description: f.Description ?? objDescriptions?.fields.get(f.Name.toLowerCase()),
+            }));
+            const primaryKeyFields = (sourceObj?.Fields ?? [])
+                .filter(f => f.IsPrimaryKey)
+                .map(f => f.Name.replace(/[^A-Za-z0-9_]/g, '_'));
+            return {
+                SourceObjectName: obj.SourceObjectName,
+                SchemaName: obj.SchemaName,
+                TableName: obj.TableName,
+                EntityName: obj.EntityName,
+                Description: sourceObj?.Description ?? objDescriptions?.objectDescription,
+                Columns: columns,
+                PrimaryKeyFields: primaryKeyFields.length > 0 ? primaryKeyFields : ['ID'],
+                SoftForeignKeys: []
+            };
+        });
+    }
+    /** Builds a lookup of object name → { objectDescription, fields: fieldName → description } from the connector's static metadata. */
+    /** Build ExistingTableInfo[] from MJ Metadata for tables that already exist in the target schemas. */
+    buildExistingTables(targetConfigs) {
+        const md = new Metadata();
+        const result = [];
+        for (const config of targetConfigs) {
+            const entity = md.Entities.find(e => e.SchemaName.toLowerCase() === config.SchemaName.toLowerCase() &&
+                e.BaseTable.toLowerCase() === config.TableName.toLowerCase());
+            if (entity) {
+                result.push({
+                    SchemaName: config.SchemaName,
+                    TableName: config.TableName,
+                    Columns: entity.Fields.map(f => ({
+                        Name: f.Name,
+                        SqlType: f.SQLFullType || 'NVARCHAR(MAX)',
+                        IsNullable: f.AllowsNull,
+                        MaxLength: f.MaxLength,
+                        Precision: f.Precision,
+                        Scale: f.Scale,
+                    }))
+                });
+            }
+        }
+        return result;
+    }
+    buildDescriptionLookup(connector) {
+        const result = new Map();
+        if (!connector)
+            return result;
+        const staticObjects = connector.GetIntegrationObjects();
+        for (const obj of staticObjects) {
+            const fieldMap = new Map();
+            for (const f of obj.Fields) {
+                if (f.Description)
+                    fieldMap.set(f.Name.toLowerCase(), f.Description);
+            }
+            result.set(obj.Name.toLowerCase(), { objectDescription: obj.Description, fields: fieldMap });
+        }
+        return result;
+    }
+    /**
+     * Resolves source object IDs to exact names from the DB, and normalizes names
+     * to match the source schema's ExternalName casing. Call once at each entry point.
+     */
+    async resolveSourceObjectNames(ids, names, sourceSchema, integrationID, user) {
+        // If IDs provided, resolve them to names from IntegrationObject records
+        if (ids && ids.length > 0) {
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: Integration Objects',
+                ExtraFilter: ids.map(id => `ID='${id}'`).join(' OR '),
+                ResultType: 'simple',
+                Fields: ['ID', 'Name'],
+            }, user);
+            if (result.Success) {
+                return result.Results.map(r => r.Name);
+            }
+        }
+        // Otherwise normalize provided names against source schema casing
+        if (names && names.length > 0) {
+            const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+            return names.map(n => nameMap.get(n.toLowerCase()) ?? n);
+        }
+        return [];
+    }
+    /**
+     * Resolves SourceObjectID/SourceObjectName on SchemaPreviewObjectInput array.
+     * Mutates the objects in place — sets SourceObjectName from ID if provided.
+     */
+    async resolveObjectInputs(objects, sourceSchema, user) {
+        const idsToResolve = objects.filter(o => o.SourceObjectID && !o.SourceObjectName).map(o => o.SourceObjectID);
+        if (idsToResolve.length > 0) {
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: Integration Objects',
+                ExtraFilter: idsToResolve.map(id => `ID='${id}'`).join(' OR '),
+                ResultType: 'simple',
+                Fields: ['ID', 'Name'],
+            }, user);
+            if (result.Success) {
+                const idToName = new Map(result.Results.map(r => [r.ID.toUpperCase(), r.Name]));
+                for (const obj of objects) {
+                    if (obj.SourceObjectID) {
+                        const resolved = idToName.get(obj.SourceObjectID.toUpperCase());
+                        if (resolved)
+                            obj.SourceObjectName = resolved;
+                    }
+                }
+            }
+        }
+        // Normalize remaining names to match source schema casing
+        const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+        for (const obj of objects) {
+            if (obj.SourceObjectName) {
+                const exact = nameMap.get(obj.SourceObjectName.toLowerCase());
+                if (exact)
+                    obj.SourceObjectName = exact;
+            }
+        }
+    }
+    getAuthenticatedUser(ctx) {
+        const user = ctx.userPayload.userRecord;
+        if (!user) {
+            throw new Error("User is not authenticated");
+        }
+        return user;
+    }
+    /** Get system user for server-side operations that need elevated permissions (cascade deletes, etc.) */
+    getSystemUser() {
+        const sysUser = UserCache.Instance.GetSystemUser();
+        if (!sysUser)
+            throw new Error('System user not available');
+        return sysUser;
+    }
+    /**
+     * Loads the CompanyIntegration + its parent Integration, then resolves the
+     * appropriate connector via ConnectorFactory.
+     *
+     * NOTE: Entity objects loaded here come from the MJServer's copy of core-entities.
+     * The integration-engine package may resolve its own copy of core-entities, causing
+     * TypeScript nominal type mismatches. At runtime the objects are structurally identical,
+     * so we cast through `unknown` at the boundary calls.
+     */
+    async resolveConnector(companyIntegrationID, contextUser) {
+        const md = new Metadata();
+        // Load the CompanyIntegration record
+        const companyIntegration = await md.GetEntityObject('MJ: Company Integrations', contextUser);
+        const loaded = await companyIntegration.Load(companyIntegrationID);
+        if (!loaded) {
+            throw new Error(`CompanyIntegration with ID "${companyIntegrationID}" not found`);
+        }
+        // Load the parent Integration record
+        const integration = await md.GetEntityObject('MJ: Integrations', contextUser);
+        const integrationLoaded = await integration.Load(companyIntegration.IntegrationID);
+        if (!integrationLoaded) {
+            throw new Error(`Integration with ID "${companyIntegration.IntegrationID}" not found`);
+        }
+        // ConnectorFactory.Resolve expects MJIntegrationEntity, which is the same type loaded above.
+        // Both this file and ConnectorFactory import from @memberjunction/core-entities.
+        const connector = ConnectorFactory.Resolve(integration);
+        return { connector, companyIntegration };
+    }
+    handleDiscoveryError(e) {
+        LogError(`Integration discovery error: ${this.formatError(e)}`);
+        return {
+            Success: false,
+            Message: `Error: ${this.formatError(e)}`
+        };
+    }
+    formatError(e) {
+        return e instanceof Error ? e.message : String(e);
+    }
+    static { this.VALID_PLATFORMS = new Set(['sqlserver', 'postgresql']); }
+    /** Validates and narrows a platform string to the supported union type. */
+    validatePlatform(platform) {
+        if (!IntegrationDiscoveryResolver_1.VALID_PLATFORMS.has(platform)) {
+            throw new Error(`Unsupported platform "${platform}". Must be one of: ${[...IntegrationDiscoveryResolver_1.VALID_PLATFORMS].join(', ')}`);
+        }
+        return platform;
+    }
+    // ── CONNECTION TEST HELPERS ────────────────────────────────────────────
+    /**
+     * Tests connectivity for a given CompanyIntegration, reusing the same pattern as IntegrationTestConnection.
+     */
+    async testConnectionForCI(companyIntegrationID, user) {
+        const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+        const testFn = connector.TestConnection.bind(connector);
+        return testFn(companyIntegration, user);
+    }
+    /**
+     * Rolls back a freshly created connection by deleting both the CompanyIntegration and Credential records.
+     */
+    async rollbackCreatedConnection(ci, credential) {
+        try {
+            await ci.Delete();
+        }
+        catch (e) {
+            LogError(`Rollback: failed to delete CompanyIntegration: ${this.formatError(e)}`);
+        }
+        try {
+            await credential.Delete();
+        }
+        catch (e) {
+            LogError(`Rollback: failed to delete Credential: ${this.formatError(e)}`);
+        }
+    }
+    /**
+     * Snapshots the current credential Values for a given credential ID so they can be restored on rollback.
+     */
+    async snapshotCredentialValues(credentialID, user) {
+        if (!credentialID)
+            return undefined;
+        const md = new Metadata();
+        const credential = await md.GetEntityObject('MJ: Credentials', user);
+        const loaded = await credential.InnerLoad(CompositeKey.FromID(credentialID));
+        return loaded ? credential.Values : undefined;
+    }
+    /**
+     * Reverts an update to a CompanyIntegration by restoring old configuration, externalSystemID,
+     * and credential values.
+     */
+    async revertUpdateConnection(ci, oldConfiguration, oldExternalSystemID, oldCredentialValues, user) {
+        try {
+            // Revert CI fields
+            let dirty = false;
+            if (oldConfiguration !== undefined) {
+                ci.Configuration = oldConfiguration;
+                dirty = true;
+            }
+            if (oldExternalSystemID !== undefined) {
+                ci.ExternalSystemID = oldExternalSystemID;
+                dirty = true;
+            }
+            if (dirty)
+                await ci.Save();
+            // Revert credential values
+            if (oldCredentialValues !== undefined && ci.CredentialID) {
+                const md = new Metadata();
+                const credential = await md.GetEntityObject('MJ: Credentials', user);
+                const loaded = await credential.InnerLoad(CompositeKey.FromID(ci.CredentialID));
+                if (loaded) {
+                    credential.Values = oldCredentialValues;
+                    await credential.Save();
+                }
+            }
+        }
+        catch (e) {
+            LogError(`Revert update connection failed: ${this.formatError(e)}`);
+        }
+    }
+    // ── CONNECTION LIFECYCLE ─────────────────────────────────────────────
+    /**
+     * Lists all CompanyIntegrations (optionally filtered by active status).
+     * Returns key fields for dashboard display without requiring a raw RunView call.
+     */
+    async IntegrationListConnections(activeOnly, companyID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const filters = [];
+            if (activeOnly)
+                filters.push('IsActive=1');
+            if (companyID)
+                filters.push(`CompanyID='${companyID}'`);
+            const filter = filters.join(' AND ');
+            const result = await rv.RunView({
+                EntityName: 'MJ: Company Integrations',
+                ExtraFilter: filter,
+                OrderBy: 'Integration ASC',
+                ResultType: 'simple',
+                Fields: [
+                    'ID', 'Integration', 'IntegrationID', 'CompanyID', 'Company',
+                    'IsActive', 'ScheduleEnabled', 'CronExpression',
+                    'ExternalSystemID', '__mj_CreatedAt'
+                ]
+            }, user);
+            if (!result.Success)
+                return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+            return {
+                Success: true,
+                Message: `${result.Results.length} connections`,
+                Connections: result.Results.map(ci => ({
+                    ID: ci.ID,
+                    IntegrationName: ci.Integration,
+                    IntegrationID: ci.IntegrationID,
+                    CompanyID: ci.CompanyID,
+                    Company: ci.Company,
+                    IsActive: ci.IsActive,
+                    ScheduleEnabled: ci.ScheduleEnabled ?? false,
+                    CronExpression: ci.CronExpression ?? undefined,
+                    CreatedAt: ci.__mj_CreatedAt?.toISOString() ?? '',
+                }))
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationListConnections error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /**
+     * Creates a CompanyIntegration with a linked Credential entity for encrypted credential storage.
+     */
+    async IntegrationCreateConnection(input, testConnection, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            // 1. Create Credential record with encrypted values
+            const credential = await md.GetEntityObject('MJ: Credentials', user);
+            credential.NewRecord();
+            credential.CredentialTypeID = input.CredentialTypeID;
+            credential.Name = input.CredentialName;
+            credential.Values = input.CredentialValues;
+            credential.IsActive = true;
+            const credSaved = await credential.Save();
+            if (!credSaved) {
+                const err = credential.LatestResult?.Message || 'Unknown error';
+                return { Success: false, Message: `Failed to create Credential: ${err}` };
+            }
+            const credentialID = credential.ID;
+            // 2. Create CompanyIntegration linked to the Credential
+            const ci = await md.GetEntityObject('MJ: Company Integrations', user);
+            ci.NewRecord();
+            ci.IntegrationID = input.IntegrationID;
+            ci.CompanyID = input.CompanyID;
+            ci.CredentialID = credentialID;
+            ci.IsActive = true;
+            ci.Name = input.CredentialName; // Name is required on CompanyIntegration
+            if (input.ExternalSystemID)
+                ci.ExternalSystemID = input.ExternalSystemID;
+            if (input.Configuration)
+                ci.Configuration = input.Configuration;
+            const saved = await ci.Save();
+            if (!saved) {
+                const validationErrors = ci.LatestResult?.Message || 'Unknown validation error';
+                return { Success: false, Message: `Failed to save CompanyIntegration: ${validationErrors}` };
+            }
+            // 3. Optionally test the connection; rollback on failure
+            if (testConnection) {
+                const testResult = await this.testConnectionForCI(ci.ID, user);
+                if (!testResult.Success) {
+                    await this.rollbackCreatedConnection(ci, credential);
+                    return {
+                        Success: false,
+                        Message: `Connection test failed: ${testResult.Message}. Connection was not saved.`,
+                        ConnectionTestSuccess: false,
+                        ConnectionTestMessage: testResult.Message
+                    };
+                }
+                return {
+                    Success: true,
+                    Message: 'Connection created and test passed',
+                    CompanyIntegrationID: ci.ID,
+                    CredentialID: credentialID,
+                    ConnectionTestSuccess: true,
+                    ConnectionTestMessage: testResult.Message
+                };
+            }
+            return {
+                Success: true,
+                Message: 'Connection created',
+                CompanyIntegrationID: ci.ID,
+                CredentialID: credentialID
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationCreateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /**
+     * Updates credential values and/or configuration on an existing CompanyIntegration.
+     */
+    async IntegrationUpdateConnection(companyIntegrationID, credentialValues, configuration, externalSystemID, testConnection, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded)
+                return { Success: false, Message: 'CompanyIntegration not found' };
+            // Snapshot old values for rollback if testConnection is requested
+            const oldCredentialValues = credentialValues ? await this.snapshotCredentialValues(ci.CredentialID, user) : undefined;
+            const oldConfiguration = ci.Configuration;
+            const oldExternalSystemID = ci.ExternalSystemID;
+            // Update linked Credential values if provided
+            if (credentialValues) {
+                const credentialID = ci.CredentialID;
+                if (!credentialID) {
+                    return { Success: false, Message: 'No linked Credential — use IntegrationCreateConnection first' };
+                }
+                const credential = await md.GetEntityObject('MJ: Credentials', user);
+                const credLoaded = await credential.InnerLoad(CompositeKey.FromID(credentialID));
+                if (!credLoaded)
+                    return { Success: false, Message: 'Linked Credential not found' };
+                credential.Values = credentialValues;
+                if (!await credential.Save())
+                    return { Success: false, Message: 'Failed to update Credential' };
+            }
+            let dirty = false;
+            if (configuration !== undefined && configuration !== null) {
+                ci.Configuration = configuration;
+                dirty = true;
+            }
+            if (externalSystemID !== undefined && externalSystemID !== null) {
+                ci.ExternalSystemID = externalSystemID;
+                dirty = true;
+            }
+            if (dirty && !await ci.Save())
+                return { Success: false, Message: 'Failed to save CompanyIntegration' };
+            // Optionally test the connection; revert on failure
+            if (testConnection) {
+                const testResult = await this.testConnectionForCI(companyIntegrationID, user);
+                if (!testResult.Success) {
+                    await this.revertUpdateConnection(ci, oldConfiguration, oldExternalSystemID, oldCredentialValues, user);
+                    return { Success: false, Message: `Connection test failed: ${testResult.Message}. Changes have been reverted.` };
+                }
+                return { Success: true, Message: 'Updated and connection test passed' };
+            }
+            return { Success: true, Message: 'Updated' };
+        }
+        catch (e) {
+            LogError(`IntegrationUpdateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /**
+     * Soft-deletes a CompanyIntegration by setting IsActive=false.
+     */
+    async IntegrationDeactivateConnection(companyIntegrationID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded)
+                return { Success: false, Message: 'CompanyIntegration not found' };
+            ci.IsActive = false;
+            if (!await ci.Save())
+                return { Success: false, Message: 'Failed to deactivate' };
+            return { Success: true, Message: 'Deactivated' };
+        }
+        catch (e) {
+            LogError(`IntegrationDeactivateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /**
+     * Reactivates a previously deactivated CompanyIntegration by setting IsActive=true.
+     */
+    async IntegrationReactivateConnection(companyIntegrationID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded)
+                return { Success: false, Message: 'CompanyIntegration not found' };
+            ci.IsActive = true;
+            if (!await ci.Save())
+                return { Success: false, Message: `Failed to reactivate: ${ci.LatestResult?.Message ?? 'Unknown error'}` };
+            return { Success: true, Message: 'Reactivated' };
+        }
+        catch (e) {
+            LogError(`IntegrationReactivateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    // ── ENTITY MAPS ─────────────────────────────────────────────────────
+    /**
+     * Batch creates entity maps by entity name (resolved by lookup).
+     * Call AFTER the schema pipeline has created the target entities.
+     */
+    async IntegrationCreateEntityMaps(companyIntegrationID, entityMaps, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            // Batch resolve entity names → IDs using cached Metadata
+            const namesToResolve = entityMaps.filter(m => m.EntityName && !m.EntityID).map(m => m.EntityName);
+            const nameToID = new Map();
+            if (namesToResolve.length > 0) {
+                const uniqueNames = [...new Set(namesToResolve)];
+                for (const name of uniqueNames) {
+                    const entity = md.EntityByName(name);
+                    if (entity) {
+                        nameToID.set(name, entity.ID);
+                    }
+                }
+                const unresolved = uniqueNames.filter(n => !nameToID.has(n));
+                if (unresolved.length > 0) {
+                    return {
+                        Success: false,
+                        Message: `Entities not found: ${unresolved.join(', ')}. Run the schema pipeline first.`
+                    };
+                }
+            }
+            const created = [];
+            for (const mapDef of entityMaps) {
+                const entityID = mapDef.EntityID || nameToID.get(mapDef.EntityName || '');
+                if (!entityID) {
+                    return { Success: false, Message: `No EntityID or EntityName for "${mapDef.ExternalObjectName}"`, Created: created };
+                }
+                const em = await md.GetEntityObject('MJ: Company Integration Entity Maps', user);
+                em.NewRecord();
+                em.CompanyIntegrationID = companyIntegrationID;
+                em.ExternalObjectName = mapDef.ExternalObjectName;
+                em.EntityID = entityID;
+                const syncDir = mapDef.SyncDirection || 'Pull';
+                if (!isValidSyncDirection(syncDir)) {
+                    return { Success: false, Message: `Invalid SyncDirection "${syncDir}" for "${mapDef.ExternalObjectName}". Must be one of: ${VALID_SYNC_DIRECTIONS.join(', ')}`, Created: created };
+                }
+                em.SyncDirection = syncDir;
+                em.Priority = mapDef.Priority || 0;
+                em.Status = 'Active';
+                if (!await em.Save()) {
+                    return { Success: false, Message: `Failed to create map for ${mapDef.ExternalObjectName}`, Created: created };
+                }
+                const entityMapID = em.ID;
+                // Create field maps if provided
+                if (mapDef.FieldMaps) {
+                    for (const fmDef of mapDef.FieldMaps) {
+                        const fm = await md.GetEntityObject('MJ: Company Integration Field Maps', user);
+                        fm.NewRecord();
+                        fm.EntityMapID = entityMapID;
+                        fm.SourceFieldName = fmDef.SourceFieldName;
+                        fm.DestinationFieldName = fmDef.DestinationFieldName;
+                        fm.IsKeyField = fmDef.IsKeyField || false;
+                        fm.IsRequired = fmDef.IsRequired || false;
+                        fm.Status = 'Active';
+                        await fm.Save();
+                    }
+                }
+                created.push({
+                    EntityMapID: entityMapID,
+                    ExternalObjectName: mapDef.ExternalObjectName,
+                    FieldMapCount: mapDef.FieldMaps?.length || 0
+                });
+            }
+            return { Success: true, Message: `Created ${created.length} entity maps`, Created: created };
+        }
+        catch (e) {
+            LogError(`IntegrationCreateEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    // ── SCHEMA EXECUTION ────────────────────────────────────────────────
+    /**
+     * Generates schema artifacts from connector introspection and runs the full
+     * RSU pipeline: write migration file → execute SQL → run CodeGen →
+     * compile TypeScript → restart MJAPI → git commit (if enabled).
+     *
+     * Replaces the old two-step IntegrationSchemaPreview + IntegrationWriteSchemaFiles
+     * pattern. Use IntegrationSchemaPreview to preview generated SQL without applying.
+     */
+    async IntegrationApplySchema(companyIntegrationID, objects, platform, skipGitCommit, skipRestart, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+            const introspect = connector.IntrospectSchema.bind(connector);
+            const sourceSchema = await introspect(companyIntegration, user);
+            await this.resolveObjectInputs(objects, sourceSchema, user);
+            const requestedNames = new Set(objects.map(o => o.SourceObjectName));
+            const filteredSchema = {
+                Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
+            };
+            const validatedPlatform = this.validatePlatform(platform);
+            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, validatedPlatform, connector);
+            const input = {
+                SourceSchema: filteredSchema,
+                TargetConfigs: targetConfigs,
+                Platform: validatedPlatform,
+                MJVersion: process.env.MJ_VERSION ?? '5.11.0',
+                SourceType: companyIntegration.Integration,
+                AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+                MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+                MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+                ExistingTables: this.buildExistingTables(targetConfigs),
+                EntitySettingsForTargets: {}
+            };
+            const builder = new SchemaBuilder();
+            const { SchemaOutput, PipelineResult } = await builder.RunSchemaPipeline(input, {
+                SkipGitCommit: skipGitCommit,
+                SkipRestart: skipRestart,
+            });
+            return {
+                Success: PipelineResult.Success,
+                Message: PipelineResult.Success
+                    ? `Schema applied — ${PipelineResult.EntitiesProcessed ?? 0} entities processed`
+                    : `Pipeline failed at '${PipelineResult.ErrorStep}': ${PipelineResult.ErrorMessage}`,
+                Steps: PipelineResult.Steps.map((s) => ({
+                    Name: s.Name,
+                    Status: s.Status,
+                    DurationMs: s.DurationMs,
+                    Message: s.Message,
+                })),
+                MigrationFilePath: PipelineResult.MigrationFilePath,
+                EntitiesProcessed: PipelineResult.EntitiesProcessed,
+                GitCommitSuccess: PipelineResult.GitCommitSuccess,
+                APIRestarted: PipelineResult.APIRestarted,
+                Warnings: SchemaOutput.Warnings.length > 0 ? SchemaOutput.Warnings : undefined,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationApplySchema error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /**
+     * Batch apply schema for multiple connectors in one RSU pipeline run.
+     * Each item specifies a companyIntegrationID + source objects to create tables for.
+     * All migrations run sequentially, then ONE CodeGen, ONE compile, ONE git PR, ONE restart.
+     */
+    async IntegrationApplySchemaBatch(items, platform, skipGitCommit, skipRestart, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
+            const pipelineInputs = [];
+            const itemResults = [];
+            // Phase 1: Build schema artifacts for each connector's objects
+            for (const item of items) {
+                try {
+                    const { schemaOutput, rsuInput } = await this.buildSchemaForConnector(item.CompanyIntegrationID, item.Objects, validatedPlatform, user, skipGitCommit, skipRestart);
+                    pipelineInputs.push(rsuInput);
+                    itemResults.push({
+                        CompanyIntegrationID: item.CompanyIntegrationID,
+                        Success: true,
+                        Message: `Schema generated for ${item.Objects.length} object(s)`,
+                        Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                    });
+                }
+                catch (e) {
+                    itemResults.push({
+                        CompanyIntegrationID: item.CompanyIntegrationID,
+                        Success: false,
+                        Message: this.formatError(e),
+                    });
+                }
+            }
+            // Phase 2: Run all successful migrations through one pipeline batch
+            if (pipelineInputs.length === 0) {
+                return { Success: false, Message: 'No valid schema inputs to process', Items: itemResults };
+            }
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch(pipelineInputs);
+            return {
+                Success: batchResult.SuccessCount > 0,
+                Message: `Batch complete: ${batchResult.SuccessCount} succeeded, ${batchResult.FailureCount} failed`,
+                Items: itemResults,
+                Steps: batchResult.Results[0]?.Steps.map((s) => ({
+                    Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+                })),
+                GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                APIRestarted: batchResult.Results[0]?.APIRestarted,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationApplySchemaBatch error: ${e}`);
+            return { Success: false, Message: this.formatError(e), Items: [] };
+        }
+    }
+    // ── APPLY ALL (Full Automatic Flow) ──────────────────────────────────
+    /**
+     * Full automatic "Apply All" flow for MJ integrations.
+     * 1. Auto-generates schema/table names from the integration name + source object names
+     * 2. Builds DDL + additionalSchemaInfo
+     * 3. Runs RSU pipeline (migration → CodeGen → compile → git → restart)
+     * 4. Creates CompanyIntegrationEntityMap records for each object
+     * 5. Creates CompanyIntegrationFieldMap records for each field (1:1 mapping)
+     * 6. Starts sync for the integration
+     */
+    async IntegrationApplyAll(input, platform, skipGitCommit, skipRestart, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
+            // Step 1: Resolve connector and derive schema name
+            const { connector, companyIntegration } = await this.resolveConnector(input.CompanyIntegrationID, user);
+            const schemaName = this.deriveSchemaName(companyIntegration.Integration);
+            // Step 2: Resolve object IDs to names, build inputs with per-object Fields
+            const sourceSchema = await connector.IntrospectSchema.bind(connector)(companyIntegration, user);
+            const objectIDs = input.SourceObjects.map(so => so.SourceObjectID);
+            const resolvedNames = await this.resolveSourceObjectNames(objectIDs, undefined, sourceSchema, companyIntegration.IntegrationID, user);
+            // Build SchemaPreviewObjectInput with Fields carried from SourceObjectInput
+            const fieldsByID = new Map(input.SourceObjects.map(so => [so.SourceObjectID, so.Fields]));
+            const objects = resolvedNames.map((name, i) => {
+                const obj = new SchemaPreviewObjectInput();
+                obj.SourceObjectName = name;
+                obj.SchemaName = schemaName;
+                obj.TableName = name.replace(/[^A-Za-z0-9_]/g, '_');
+                obj.EntityName = name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
+                obj.Fields = fieldsByID.get(objectIDs[i]) ?? undefined;
+                return obj;
+            });
+            // Step 3: Build schema and RSU pipeline input
+            const { schemaOutput, rsuInput } = await this.buildSchemaForConnector(input.CompanyIntegrationID, objects, validatedPlatform, user, skipGitCommit, skipRestart);
+            // Step 4: Inject integration post-restart payload into RSU input.
+            const { join } = await import('node:path');
+            const rsuWorkDir = process.env.RSU_WORK_DIR || process.cwd();
+            const pendingWorkDir = join(rsuWorkDir, '.rsu_pending');
+            const pendingFilePath = join(pendingWorkDir, `${Date.now()}.json`);
+            // Build per-object field map for pending file (null = all fields)
+            const sourceObjectFields = {};
+            for (const so of input.SourceObjects) {
+                const resolvedName = resolvedNames[objectIDs.indexOf(so.SourceObjectID)];
+                if (resolvedName)
+                    sourceObjectFields[resolvedName] = so.Fields ?? null;
+            }
+            const pendingPayload = {
+                CompanyIntegrationID: input.CompanyIntegrationID,
+                SourceObjectNames: resolvedNames,
+                SourceObjectFields: sourceObjectFields,
+                SchemaName: schemaName,
+                CronExpression: input.CronExpression,
+                ScheduleTimezone: input.ScheduleTimezone,
+                StartSync: input.StartSync,
+                FullSync: input.FullSync ?? false,
+                SyncScope: input.SyncScope ?? 'created',
+                CreatedAt: new Date().toISOString(),
+            };
+            rsuInput.PostRestartFiles = [
+                { Path: pendingFilePath, Content: JSON.stringify(pendingPayload, null, 2) }
+            ];
+            // Step 5: Run pipeline (restart kills process at the end)
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch([rsuInput]);
+            const migrationSucceeded = batchResult.SuccessCount > 0;
+            const pipelineSteps = batchResult.Results[0]?.Steps.map((s) => ({
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+            }));
+            // If pipeline failed, clean up pending file and return error
+            if (!migrationSucceeded) {
+                try {
+                    (await import('node:fs')).unlinkSync(pendingFilePath);
+                }
+                catch { /* may not exist */ }
+                return {
+                    Success: false,
+                    Message: `Pipeline failed: ${batchResult.Results[0]?.ErrorMessage ?? 'unknown error'}`,
+                    Steps: pipelineSteps,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+            // If we get here, pipeline succeeded but restart may or may not have happened yet.
+            // If restart happened, this code never executes (process died).
+            // If skipRestart=true, we can do entity maps now.
+            if (skipRestart) {
+                await Metadata.Provider.Refresh();
+                const entityMapsCreated = await this.createEntityAndFieldMaps(input.CompanyIntegrationID, objects, connector, companyIntegration, schemaName, user);
+                const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
+                const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
+                const syncRunID = input.StartSync !== false
+                    ? await this.startSyncAfterApply(input.CompanyIntegrationID, user, scopedMapIDs, input.FullSync)
+                    : null;
+                // Create schedule if requested
+                let scheduledJobID;
+                if (input.CronExpression) {
+                    try {
+                        scheduledJobID = await this.createScheduleForConnector(input.CompanyIntegrationID, companyIntegration.Integration, input.CronExpression, input.ScheduleTimezone, user) ?? undefined;
+                    }
+                    catch (schedErr) {
+                        console.warn(`[Integration] Schedule creation failed: ${schedErr}`);
+                    }
+                }
+                try {
+                    (await import('node:fs')).unlinkSync(pendingFilePath);
+                }
+                catch { /* already consumed */ }
+                return {
+                    Success: true,
+                    Message: `Applied ${objects.length} object(s) — ${entityMapsCreated.length} entity maps created${syncRunID ? ', sync started' : ''}${scheduledJobID ? ', schedule created' : ''}`,
+                    Steps: pipelineSteps,
+                    EntityMapsCreated: entityMapsCreated,
+                    SyncRunID: syncRunID ?? undefined,
+                    ScheduledJobID: scheduledJobID,
+                    GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                    APIRestarted: false,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+            // If restart is enabled, this return may or may not execute
+            // (depends on whether PM2 kills process before GraphQL response is sent)
+            return {
+                Success: true,
+                Message: `Applied ${objects.length} object(s) — entity maps will be created after restart`,
+                Steps: pipelineSteps,
+                GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                APIRestarted: true,
+                Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationApplyAll error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /** Derives a SQL-safe schema name from the integration name (e.g., "HubSpot" → "hubspot"). */
+    deriveSchemaName(integrationName) {
+        return (integrationName || 'integration').toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    }
+    /** Builds SchemaPreviewObjectInput[] from source object name strings, using auto-derived schema/table names. */
+    buildObjectInputsFromNames(sourceObjectNames, schemaName) {
+        return sourceObjectNames.map(name => {
+            const obj = new SchemaPreviewObjectInput();
+            obj.SourceObjectName = name;
+            obj.SchemaName = schemaName;
+            obj.TableName = name.replace(/[^A-Za-z0-9_]/g, '_');
+            obj.EntityName = name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
+            return obj;
+        });
+    }
     /**
-     * Discovers available objects/tables in the external system.
+     * After pipeline success, creates CompanyIntegrationEntityMap + CompanyIntegrationFieldMap
+     * records for each source object by matching schema + table name to newly created entities.
      */
-    async IntegrationDiscoverObjects(companyIntegrationID, ctx) {
+    async createEntityAndFieldMaps(companyIntegrationID, objects, connector, companyIntegration, schemaName, user) {
+        const md = new Metadata();
+        const results = [];
+        for (const obj of objects) {
+            const entityMapResult = await this.createSingleEntityMap(companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md);
+            if (entityMapResult) {
+                results.push(entityMapResult);
+            }
+        }
+        return results;
+    }
+    /** Creates a single entity map + field maps for one source object. */
+    async createSingleEntityMap(companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md) {
+        // Find the entity by schema + table name
+        const entityInfo = md.Entities.find(e => e.SchemaName.toLowerCase() === schemaName.toLowerCase()
+            && e.BaseTable.toLowerCase() === obj.TableName.toLowerCase());
+        if (!entityInfo) {
+            LogError(`IntegrationApplyAll: entity not found for ${schemaName}.${obj.TableName}`);
+            return null;
+        }
+        // Create entity map
+        const em = await md.GetEntityObject('MJ: Company Integration Entity Maps', user);
+        em.NewRecord();
+        em.CompanyIntegrationID = companyIntegrationID;
+        em.ExternalObjectName = obj.SourceObjectName;
+        em.EntityID = entityInfo.ID;
+        em.SyncDirection = 'Pull';
+        em.Priority = 0;
+        em.Status = 'Active';
+        em.SyncEnabled = true;
+        if (!await em.Save()) {
+            LogError(`IntegrationApplyAll: failed to save entity map for ${obj.SourceObjectName}`);
+            return null;
+        }
+        // Discover fields from the source and create 1:1 field maps
+        const fieldMapCount = await this.createFieldMapsForEntityMap(em.ID, obj.SourceObjectName, connector, companyIntegration, user, md);
+        return {
+            SourceObjectName: obj.SourceObjectName,
+            EntityName: entityInfo.Name,
+            EntityMapID: em.ID,
+            FieldMapCount: fieldMapCount,
+        };
+    }
+    /** Discovers fields from the source object and creates 1:1 field maps. */
+    async createFieldMapsForEntityMap(entityMapID, sourceObjectName, connector, companyIntegration, user, md) {
+        let fieldCount = 0;
+        try {
+            const discoverFields = connector.DiscoverFields.bind(connector);
+            const fields = await discoverFields(companyIntegration, sourceObjectName, user);
+            for (const field of fields) {
+                const fm = await md.GetEntityObject('MJ: Company Integration Field Maps', user);
+                fm.NewRecord();
+                fm.EntityMapID = entityMapID;
+                fm.SourceFieldName = field.Name;
+                fm.DestinationFieldName = field.Name.replace(/[^A-Za-z0-9_]/g, '_');
+                fm.IsKeyField = field.IsUniqueKey;
+                fm.IsRequired = field.IsRequired;
+                fm.Direction = 'SourceToDest';
+                fm.Status = 'Active';
+                fm.Priority = 0;
+                if (await fm.Save()) {
+                    fieldCount++;
+                }
+            }
+        }
+        catch (e) {
+            LogError(`IntegrationApplyAll: failed to discover/create field maps for ${sourceObjectName}: ${this.formatError(e)}`);
+        }
+        return fieldCount;
+    }
+    /** Starts sync after a successful apply-all pipeline, returning the run ID if available. */
+    async startSyncAfterApply(companyIntegrationID, user, entityMapIDs, fullSync) {
+        try {
+            await IntegrationEngine.Instance.Config(false, user);
+            const options = {};
+            if (entityMapIDs?.length)
+                options.EntityMapIDs = entityMapIDs;
+            if (fullSync)
+                options.FullSync = true;
+            const finalOptions = Object.keys(options).length > 0 ? options : undefined;
+            const syncPromise = IntegrationEngine.Instance.RunSync(companyIntegrationID, user, 'Manual', undefined, undefined, finalOptions);
+            // Fire and forget — don't block the response
+            syncPromise.catch(err => {
+                LogError(`IntegrationApplyAll: background sync failed for ${companyIntegrationID}: ${err}`);
+            });
+            // Small delay to let the run record get created
+            await new Promise(resolve => setTimeout(resolve, 200));
+            const rv = new RunView();
+            const runResult = await rv.RunView({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND Status='In Progress'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID']
+            }, user);
+            return (runResult.Success && runResult.Results.length > 0) ? runResult.Results[0].ID : null;
+        }
+        catch (e) {
+            LogError(`IntegrationApplyAll: sync start failed: ${this.formatError(e)}`);
+            return null;
+        }
+    }
+    /**
+     * Build schema artifacts for a single connector's objects.
+     * Shared by IntegrationApplySchema (single) and IntegrationApplySchemaBatch (batch).
+     */
+    async buildSchemaForConnector(companyIntegrationID, objects, platform, user, skipGitCommit, skipRestart) {
+        const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+        const introspect = connector.IntrospectSchema.bind(connector);
+        const sourceSchema = await introspect(companyIntegration, user);
+        // Normalize names to match source schema casing
+        const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+        for (const obj of objects) {
+            const exact = nameMap.get(obj.SourceObjectName.toLowerCase());
+            if (exact)
+                obj.SourceObjectName = exact;
+        }
+        const requestedNames = new Set(objects.map(o => o.SourceObjectName));
+        const filteredSchema = {
+            Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
+        };
+        const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, platform, connector);
+        const input = {
+            SourceSchema: filteredSchema,
+            TargetConfigs: targetConfigs,
+            Platform: platform,
+            MJVersion: process.env.MJ_VERSION ?? '5.11.0',
+            SourceType: companyIntegration.Integration,
+            AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+            MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+            MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+            ExistingTables: this.buildExistingTables(targetConfigs),
+            EntitySettingsForTargets: {}
+        };
+        const builder = new SchemaBuilder();
+        const schemaOutput = builder.BuildSchema(input);
+        if (schemaOutput.Errors.length > 0) {
+            throw new Error(`Schema generation failed: ${schemaOutput.Errors.join('; ')}`);
+        }
+        const rsuInput = builder.BuildRSUInput(schemaOutput, input, { SkipGitCommit: skipGitCommit, SkipRestart: skipRestart });
+        return { schemaOutput, rsuInput };
+    }
+    // ── SYNC ────────────────────────────────────────────────────────────
+    /**
+     * Starts an async integration sync. Returns immediately with the run ID.
+     * Sends a webhook to the registered callback when complete.
+     */
+    async IntegrationStartSync(companyIntegrationID, webhookURL, fullSync, entityMapIDs, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
-            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
-            // Cast through unknown to bridge duplicate package type declarations
-            // (integration-engine resolves its own node_modules copies of core/core-entities)
-            const discoverObjects = connector.DiscoverObjects.bind(connector);
-            const objects = await discoverObjects(companyIntegration, user);
+            await IntegrationEngine.Instance.Config(false, user);
+            const syncOptions = {};
+            if (fullSync)
+                syncOptions.FullSync = true;
+            if (entityMapIDs?.length)
+                syncOptions.EntityMapIDs = entityMapIDs;
+            // Fire and forget — progress is tracked inside IntegrationEngine
+            const syncPromise = IntegrationEngine.Instance.RunSync(companyIntegrationID, user, 'Manual', undefined, undefined, Object.keys(syncOptions).length > 0 ? syncOptions : undefined);
+            syncPromise
+                .then(async (result) => {
+                if (webhookURL) {
+                    await this.sendWebhook(webhookURL, {
+                        event: result.Success ? 'sync_complete' : 'sync_failed',
+                        companyIntegrationID,
+                        success: result.Success,
+                        recordsProcessed: result.RecordsProcessed,
+                        recordsCreated: result.RecordsCreated,
+                        recordsUpdated: result.RecordsUpdated,
+                        recordsErrored: result.RecordsErrored,
+                        errorCount: result.Errors.length
+                    });
+                }
+            })
+                .catch(async (err) => {
+                console.error(`[Integration] Background sync failed for ${companyIntegrationID}:`, err);
+                if (webhookURL) {
+                    await this.sendWebhook(webhookURL, {
+                        event: 'sync_failed',
+                        companyIntegrationID,
+                        success: false,
+                        error: err instanceof Error ? err.message : String(err)
+                    });
+                }
+            });
+            // Small delay to let the run record get created
+            await new Promise(resolve => setTimeout(resolve, 200));
+            const rv = new RunView();
+            const runResult = await rv.RunView({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND Status='In Progress'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID', 'Status', 'StartedAt']
+            }, user);
+            const run = runResult.Success && runResult.Results.length > 0 ? runResult.Results[0] : null;
             return {
                 Success: true,
-                Message: `Discovered ${objects.length} objects`,
-                Objects: objects.map(o => ({
-                    Name: o.Name,
-                    Label: o.Label,
-                    SupportsIncrementalSync: o.SupportsIncrementalSync,
-                    SupportsWrite: o.SupportsWrite
-                }))
+                Message: 'Sync started',
+                RunID: run?.ID
             };
         }
         catch (e) {
-            return this.handleDiscoveryError(e);
+            LogError(`IntegrationStartSync error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
         }
     }
     /**
-     * Discovers fields on a specific external object.
+     * Cancels a running sync by marking its status as Cancelled.
      */
-    async IntegrationDiscoverFields(companyIntegrationID, objectName, ctx) {
+    async IntegrationCancelSync(companyIntegrationID, ctx) {
+        try {
+            this.getAuthenticatedUser(ctx);
+            // Signal the engine to abort the running sync
+            const cancelled = IntegrationEngine.CancelSync(companyIntegrationID);
+            if (!cancelled) {
+                return { Success: false, Message: 'No active sync found for this connector' };
+            }
+            return { Success: true, Message: 'Sync cancellation signalled — will stop after current batch completes' };
+        }
+        catch (e) {
+            LogError(`IntegrationCancelSync error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    // ── SCHEDULE ────────────────────────────────────────────────────────
+    async IntegrationCreateSchedule(input, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
-            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
-            // Cast through unknown to bridge duplicate package type declarations
-            const discoverFields = connector.DiscoverFields.bind(connector);
-            const fields = await discoverFields(companyIntegration, objectName, user);
+            const md = new Metadata();
+            const rv = new RunView();
+            // Find IntegrationSync job type
+            const jobTypeResult = await rv.RunView({
+                EntityName: 'MJ: Scheduled Job Types',
+                ExtraFilter: `DriverClass='IntegrationSyncScheduledJobDriver'`,
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID']
+            }, user);
+            if (!jobTypeResult.Success || jobTypeResult.Results.length === 0) {
+                return { Success: false, Message: 'IntegrationSync scheduled job type not found' };
+            }
+            const jobTypeID = jobTypeResult.Results[0].ID;
+            const job = await md.GetEntityObject('MJ: Scheduled Jobs', user);
+            job.NewRecord();
+            job.JobTypeID = jobTypeID;
+            job.Name = input.Name;
+            if (input.Description)
+                job.Description = input.Description;
+            job.CronExpression = input.CronExpression;
+            job.Timezone = input.Timezone || 'UTC';
+            job.Status = 'Active';
+            job.OwnerUserID = user.ID;
+            job.Configuration = JSON.stringify({ CompanyIntegrationID: input.CompanyIntegrationID });
+            job.NextRunAt = CronExpressionHelper.GetNextRunTime(input.CronExpression, input.Timezone || 'UTC');
+            if (!await job.Save())
+                return { Success: false, Message: 'Failed to create schedule' };
+            // Link to CompanyIntegration
+            const ci = await md.GetEntityObject('MJ: Company Integrations', user);
+            const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(input.CompanyIntegrationID));
+            if (ciLoaded) {
+                ci.ScheduleEnabled = true;
+                ci.ScheduleType = 'Cron';
+                ci.CronExpression = input.CronExpression;
+                await ci.Save();
+            }
+            return { Success: true, Message: 'Schedule created', ScheduledJobID: job.ID };
+        }
+        catch (e) {
+            LogError(`IntegrationCreateSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationUpdateSchedule(scheduledJobID, cronExpression, timezone, name, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const job = await md.GetEntityObject('MJ: Scheduled Jobs', user);
+            const loaded = await job.InnerLoad(CompositeKey.FromID(scheduledJobID));
+            if (!loaded)
+                return { Success: false, Message: 'ScheduledJob not found' };
+            if (cronExpression)
+                job.CronExpression = cronExpression;
+            if (timezone)
+                job.Timezone = timezone;
+            if (name)
+                job.Name = name;
+            if (cronExpression || timezone) {
+                job.NextRunAt = CronExpressionHelper.GetNextRunTime(job.CronExpression, job.Timezone || 'UTC');
+            }
+            if (!await job.Save())
+                return { Success: false, Message: 'Failed to update' };
+            return { Success: true, Message: 'Updated' };
+        }
+        catch (e) {
+            LogError(`IntegrationUpdateSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationToggleSchedule(scheduledJobID, enabled, ctx) {
+        try {
+            this.getAuthenticatedUser(ctx); // verify caller is authenticated
+            const sysUser = this.getSystemUser();
+            const md = new Metadata();
+            const job = await md.GetEntityObject('MJ: Scheduled Jobs', sysUser);
+            const loaded = await job.InnerLoad(CompositeKey.FromID(scheduledJobID));
+            if (!loaded)
+                return { Success: false, Message: 'ScheduledJob not found' };
+            job.Status = enabled ? 'Active' : 'Paused';
+            if (!await job.Save()) {
+                const err = job.LatestResult?.Message || 'Unknown error';
+                return { Success: false, Message: `Failed to toggle: ${err}` };
+            }
+            return { Success: true, Message: enabled ? 'Activated' : 'Paused' };
+        }
+        catch (e) {
+            LogError(`IntegrationToggleSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationDeleteSchedule(scheduledJobID, companyIntegrationID, ctx) {
+        try {
+            this.getAuthenticatedUser(ctx); // verify caller is authenticated
+            const sysUser = this.getSystemUser(); // use system user for delete operations
+            const md = new Metadata();
+            // Unlink from CI if provided
+            if (companyIntegrationID) {
+                const ci = await md.GetEntityObject('MJ: Company Integrations', sysUser);
+                const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+                if (ciLoaded) {
+                    ci.ScheduleEnabled = false;
+                    ci.CronExpression = null;
+                    await ci.Save();
+                }
+            }
+            const rv = new RunView();
+            // Clear ScheduledJobID on any CompanyIntegration that references this job
+            const ciResult = await rv.RunView({
+                EntityName: 'MJ: Company Integrations',
+                ExtraFilter: `ScheduledJobID='${scheduledJobID}'`,
+                ResultType: 'entity_object',
+            }, sysUser);
+            if (ciResult.Success) {
+                for (const refCI of ciResult.Results) {
+                    refCI.ScheduledJobID = null;
+                    refCI.ScheduleEnabled = false;
+                    refCI.CronExpression = null;
+                    await refCI.Save();
+                }
+            }
+            // Null out ScheduledJobRunID on CompanyIntegrationRuns that reference this job's runs
+            const jobRunsResult = await rv.RunView({
+                EntityName: 'MJ: Scheduled Job Runs',
+                ExtraFilter: `ScheduledJobID='${scheduledJobID}'`,
+                ResultType: 'entity_object',
+            }, sysUser);
+            if (jobRunsResult.Success) {
+                for (const jr of jobRunsResult.Results) {
+                    // Find CompanyIntegrationRuns referencing this job run and null the FK
+                    const ciRunsResult = await rv.RunView({
+                        EntityName: 'MJ: Company Integration Runs',
+                        ExtraFilter: `ScheduledJobRunID='${jr.ID}'`,
+                        ResultType: 'entity_object',
+                    }, sysUser);
+                    if (ciRunsResult.Success) {
+                        for (const ciRun of ciRunsResult.Results) {
+                            ciRun.ScheduledJobRunID = null;
+                            await ciRun.Save();
+                        }
+                    }
+                }
+            }
+            // Now delete job runs + job in a transaction
+            const tg = await Metadata.Provider.CreateTransactionGroup();
+            if (jobRunsResult.Success) {
+                for (const run of jobRunsResult.Results) {
+                    run.TransactionGroup = tg;
+                    await run.Delete();
+                }
+            }
+            const job = await md.GetEntityObject('MJ: Scheduled Jobs', sysUser);
+            const loaded = await job.InnerLoad(CompositeKey.FromID(scheduledJobID));
+            if (!loaded)
+                return { Success: false, Message: 'ScheduledJob not found' };
+            job.TransactionGroup = tg;
+            await job.Delete();
+            const deleted = await tg.Submit();
+            if (!deleted) {
+                const err = job.LatestResult?.Message || 'Unknown error';
+                return { Success: false, Message: `Failed to delete: ${err}` };
+            }
+            return { Success: true, Message: `Deleted (${jobRunsResult.Results?.length ?? 0} runs removed)` };
+        }
+        catch (e) {
+            LogError(`IntegrationDeleteSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationListSchedules(companyIntegrationID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: Scheduled Jobs',
+                ExtraFilter: `Configuration LIKE '%"CompanyIntegrationID":"${companyIntegrationID}"%'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                ResultType: 'simple',
+                Fields: ['ID', 'Name', 'Status', 'CronExpression', 'Timezone', 'NextRunAt', 'LastRunAt', 'RunCount', 'SuccessCount', 'FailureCount']
+            }, user);
+            if (!result.Success)
+                return { Success: false, Message: result.ErrorMessage || 'Query failed' };
             return {
                 Success: true,
-                Message: `Discovered ${fields.length} fields on "${objectName}"`,
-                Fields: fields.map(f => ({
-                    Name: f.Name,
-                    Label: f.Label,
-                    DataType: f.DataType,
-                    IsRequired: f.IsRequired,
-                    IsUniqueKey: f.IsUniqueKey,
-                    IsReadOnly: f.IsReadOnly
+                Message: `${result.Results.length} schedule(s)`,
+                Schedules: result.Results.map(r => ({
+                    ID: r.ID,
+                    Name: r.Name,
+                    Status: r.Status,
+                    CronExpression: r.CronExpression,
+                    Timezone: r.Timezone,
+                    NextRunAt: r.NextRunAt ?? undefined,
+                    LastRunAt: r.LastRunAt ?? undefined,
+                    RunCount: r.RunCount,
+                    SuccessCount: r.SuccessCount,
+                    FailureCount: r.FailureCount,
                 }))
             };
         }
         catch (e) {
-            return this.handleDiscoveryError(e);
+            LogError(`IntegrationListSchedules error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
         }
     }
-    /**
-     * Tests connectivity to the external system.
-     */
-    async IntegrationTestConnection(companyIntegrationID, ctx) {
+    // ── ENTITY MAP MANAGEMENT ──────────────────────────────────────────
+    async IntegrationListEntityMaps(companyIntegrationID, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
-            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
-            // Cast through unknown to bridge duplicate package type declarations
-            const testConnection = connector.TestConnection.bind(connector);
-            const result = await testConnection(companyIntegration, user);
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                OrderBy: 'Priority ASC',
+                ResultType: 'simple',
+                Fields: ['ID', 'EntityID', 'Entity', 'ExternalObjectName', 'SyncDirection', 'Priority', 'Status']
+            }, user);
+            if (!result.Success)
+                return { Success: false, Message: result.ErrorMessage || 'Query failed' };
             return {
-                Success: result.Success,
-                Message: result.Message,
-                ServerVersion: result.ServerVersion
+                Success: true,
+                Message: `${result.Results.length} entity maps`,
+                EntityMaps: result.Results
             };
         }
         catch (e) {
-            const error = e;
-            LogError(`IntegrationTestConnection error: ${error}`);
+            LogError(`IntegrationListEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationListFieldMaps(entityMapID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: Company Integration Field Maps',
+                ExtraFilter: `EntityMapID='${entityMapID}'`,
+                OrderBy: 'SourceFieldName',
+                ResultType: 'simple',
+                Fields: ['ID', 'EntityMapID', 'SourceFieldName', 'DestinationFieldName', 'Status']
+            }, user);
+            if (!result.Success)
+                return { Success: false, Message: result.ErrorMessage || 'Query failed' };
             return {
-                Success: false,
-                Message: `Error: ${error.message}`
+                Success: true,
+                Message: `${result.Results.length} field maps`,
+                FieldMaps: result.Results
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationListFieldMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationUpdateEntityMaps(updates, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const errors = [];
+            for (const update of updates) {
+                const em = await md.GetEntityObject('MJ: Company Integration Entity Maps', user);
+                const loaded = await em.InnerLoad(CompositeKey.FromID(update.EntityMapID));
+                if (!loaded) {
+                    errors.push(`${update.EntityMapID}: not found`);
+                    continue;
+                }
+                if (update.SyncDirection != null) {
+                    if (!isValidSyncDirection(update.SyncDirection)) {
+                        errors.push(`${update.EntityMapID}: invalid SyncDirection "${update.SyncDirection}"`);
+                        continue;
+                    }
+                    em.SyncDirection = update.SyncDirection;
+                }
+                if (update.Priority != null)
+                    em.Priority = update.Priority;
+                if (update.Status != null) {
+                    if (!isValidEntityMapStatus(update.Status)) {
+                        errors.push(`${update.EntityMapID}: invalid Status "${update.Status}"`);
+                        continue;
+                    }
+                    em.Status = update.Status;
+                }
+                if (!await em.Save())
+                    errors.push(`${update.EntityMapID}: failed to save`);
+            }
+            if (errors.length > 0)
+                return { Success: false, Message: `Errors: ${errors.join('; ')}` };
+            return { Success: true, Message: `Updated ${updates.length} entity maps` };
+        }
+        catch (e) {
+            LogError(`IntegrationUpdateEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationDeleteEntityMaps(entityMapIDs, ctx) {
+        try {
+            this.getAuthenticatedUser(ctx);
+            const sysUser = this.getSystemUser();
+            const md = new Metadata();
+            const rv = new RunView();
+            const tg = await Metadata.Provider.CreateTransactionGroup();
+            const errors = [];
+            for (const entityMapID of entityMapIDs) {
+                const em = await md.GetEntityObject('MJ: Company Integration Entity Maps', sysUser);
+                const loaded = await em.InnerLoad(CompositeKey.FromID(entityMapID));
+                if (!loaded) {
+                    errors.push(`${entityMapID}: not found`);
+                    continue;
+                }
+                // Delete field maps
+                const fmResult = await rv.RunView({
+                    EntityName: 'MJ: Company Integration Field Maps',
+                    ExtraFilter: `EntityMapID='${entityMapID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (fmResult.Success) {
+                    for (const fm of fmResult.Results) {
+                        fm.TransactionGroup = tg;
+                        await fm.Delete();
+                    }
+                }
+                // Delete watermarks
+                const wmResult = await rv.RunView({
+                    EntityName: 'MJ: Company Integration Sync Watermarks',
+                    ExtraFilter: `EntityMapID='${entityMapID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (wmResult.Success) {
+                    for (const wm of wmResult.Results) {
+                        wm.TransactionGroup = tg;
+                        await wm.Delete();
+                    }
+                }
+                // Delete record maps for THIS entity only (filter by CI + EntityID)
+                const rmResult = await rv.RunView({
+                    EntityName: 'MJ: Company Integration Record Maps',
+                    ExtraFilter: `CompanyIntegrationID='${em.CompanyIntegrationID}' AND EntityID='${em.EntityID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (rmResult.Success) {
+                    for (const rm of rmResult.Results) {
+                        rm.TransactionGroup = tg;
+                        await rm.Delete();
+                    }
+                }
+                em.TransactionGroup = tg;
+                await em.Delete();
+            }
+            const submitted = await tg.Submit();
+            if (!submitted)
+                return { Success: false, Message: 'Transaction failed — all deletes rolled back' };
+            if (errors.length > 0)
+                return { Success: false, Message: `Partial: ${errors.join('; ')}` };
+            return { Success: true, Message: `Deleted ${entityMapIDs.length} entity maps (with field maps, watermarks, record maps)` };
+        }
+        catch (e) {
+            LogError(`IntegrationDeleteEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    // ── OPERATION PROGRESS (polling) ──────────────────────────────────
+    async IntegrationGetRSUProgress(ctx) {
+        try {
+            this.getAuthenticatedUser(ctx);
+            const rsm = RuntimeSchemaManager.Instance;
+            const rsuStatus = rsm.GetStatus();
+            if (rsuStatus.Running) {
+                return {
+                    Success: true,
+                    Message: 'RSU pipeline in progress',
+                    OperationType: 'rsu',
+                    IsRunning: true,
+                    RSURunning: true,
+                    RSUStep: rsuStatus.LastRunResult ?? 'running',
+                    StartedAt: rsuStatus.LastRunAt?.toISOString(),
+                    ElapsedMs: rsuStatus.LastRunAt ? Date.now() - rsuStatus.LastRunAt.getTime() : undefined,
+                };
+            }
+            return { Success: true, Message: 'No RSU pipeline running', OperationType: 'none', IsRunning: false };
+        }
+        catch (e) {
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationGetSyncProgress(companyIntegrationID, ctx) {
+        try {
+            this.getAuthenticatedUser(ctx);
+            const syncProgress = IntegrationEngine.GetSyncProgress(companyIntegrationID);
+            if (syncProgress) {
+                return {
+                    Success: true,
+                    Message: `Sync in progress (${syncProgress.TriggerType})`,
+                    OperationType: 'sync',
+                    IsRunning: true,
+                    CurrentEntity: syncProgress.CurrentEntity,
+                    EntityMapsTotal: syncProgress.EntityMapsTotal,
+                    EntityMapsCompleted: syncProgress.EntityMapsCompleted,
+                    RecordsProcessed: syncProgress.RecordsProcessed,
+                    RecordsCreated: syncProgress.RecordsCreated,
+                    RecordsUpdated: syncProgress.RecordsUpdated,
+                    RecordsErrored: syncProgress.RecordsErrored,
+                    StartedAt: syncProgress.StartedAt.toISOString(),
+                    ElapsedMs: Date.now() - syncProgress.StartedAt.getTime(),
+                };
+            }
+            return { Success: true, Message: 'No sync running for this connector', OperationType: 'none', IsRunning: false };
+        }
+        catch (e) {
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    // ── STATUS & HISTORY (not polling — for page loads) ─────────────────
+    async IntegrationGetStatus(companyIntegrationID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded)
+                return { Success: false, Message: 'Not found' };
+            const rv = new RunView();
+            const [mapsResult, runsResult] = await rv.RunViews([
+                {
+                    EntityName: 'MJ: Company Integration Entity Maps',
+                    ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                    ResultType: 'simple',
+                    Fields: ['ID', 'Status']
+                },
+                {
+                    EntityName: 'MJ: Company Integration Runs',
+                    ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                    OrderBy: 'StartedAt DESC',
+                    MaxRows: 1,
+                    ResultType: 'simple',
+                    Fields: ['ID', 'Status', 'StartedAt', 'EndedAt', 'TotalRecords']
+                }
+            ], user);
+            const maps = mapsResult.Success ? mapsResult.Results : [];
+            const lastRun = runsResult.Success && runsResult.Results.length > 0
+                ? runsResult.Results[0]
+                : null;
+            // RSU pipeline state
+            const rsuStatus = RuntimeSchemaManager.Instance.GetStatus();
+            return {
+                Success: true,
+                Message: 'OK',
+                IsActive: ci.IsActive ?? false,
+                IntegrationName: ci.Integration,
+                CompanyIntegrationID: companyIntegrationID,
+                TotalEntityMaps: maps.length,
+                ActiveEntityMaps: maps.filter(m => m.Status === 'Active').length,
+                LastRunStatus: lastRun?.Status,
+                LastRunStartedAt: lastRun?.StartedAt,
+                LastRunEndedAt: lastRun?.EndedAt,
+                ScheduleEnabled: ci.ScheduleEnabled,
+                RSUEnabled: rsuStatus.Enabled,
+                RSURunning: rsuStatus.Running,
+                RSUOutOfSync: rsuStatus.OutOfSync,
+                RSULastRunAt: rsuStatus.LastRunAt?.toISOString(),
+                RSULastRunResult: rsuStatus.LastRunResult,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationGetStatus error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    async IntegrationGetSyncHistory(companyIntegrationID, limit, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                OrderBy: 'StartedAt DESC',
+                MaxRows: limit,
+                ResultType: 'simple',
+                Fields: ['ID', 'Status', 'StartedAt', 'EndedAt', 'TotalRecords', 'RunByUserID']
+            }, user);
+            if (!result.Success)
+                return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+            return {
+                Success: true,
+                Message: `${result.Results.length} runs`,
+                Runs: result.Results
             };
         }
+        catch (e) {
+            LogError(`IntegrationGetSyncHistory error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
     }
+    // ── CONNECTOR CAPABILITIES ──────────────────────────────────────────
     /**
-     * Returns the connector's default configuration for quick setup.
-     * Not all connectors provide defaults — returns Success: false if unavailable.
+     * Returns the CRUD capability flags for the connector bound to a CompanyIntegration.
+     * Use this to determine which operations (Create/Update/Delete/Search) are supported
+     * before attempting point-action calls.
      */
-    async IntegrationGetDefaultConfig(companyIntegrationID, ctx) {
+    async IntegrationGetConnectorCapabilities(companyIntegrationID, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
             const { connector } = await this.resolveConnector(companyIntegrationID, user);
-            const config = connector.GetDefaultConfiguration();
-            if (!config) {
+            return {
+                Success: true,
+                Message: 'OK',
+                SupportsGet: connector.SupportsGet,
+                SupportsCreate: connector.SupportsCreate,
+                SupportsUpdate: connector.SupportsUpdate,
+                SupportsDelete: connector.SupportsDelete,
+                SupportsSearch: connector.SupportsSearch,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationGetConnectorCapabilities error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    // ── APPLY ALL BATCH ─────────────────────────────────────────────────
+    /**
+     * Batch "Apply All" for multiple connectors in a single RSU pipeline run.
+     * For each connector: introspect → build schema → collect RSU input.
+     * Then run ONE pipeline batch for all connectors.
+     * Post-pipeline: create entity/field maps and start sync for each success.
+     */
+    async IntegrationApplyAllBatch(input, platform, skipGitCommit, skipRestart, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
+            // Phase 1: Build schema for each connector in parallel
+            const buildResults = await Promise.allSettled(input.Connectors.map(async (connInput) => {
+                const { connector, companyIntegration } = await this.resolveConnector(connInput.CompanyIntegrationID, user);
+                const schemaName = this.deriveSchemaName(companyIntegration.Integration);
+                // Resolve object IDs to names with per-object Fields
+                const sourceSchema = await connector.IntrospectSchema.bind(connector)(companyIntegration, user);
+                const objectIDs = connInput.SourceObjects.map(so => so.SourceObjectID);
+                const resolvedNames = await this.resolveSourceObjectNames(objectIDs, undefined, sourceSchema, companyIntegration.IntegrationID, user);
+                const fieldsByID = new Map(connInput.SourceObjects.map(so => [so.SourceObjectID, so.Fields]));
+                const objects = resolvedNames.map((name, i) => {
+                    const obj = new SchemaPreviewObjectInput();
+                    obj.SourceObjectName = name;
+                    obj.SchemaName = schemaName;
+                    obj.TableName = name.replace(/[^A-Za-z0-9_]/g, '_');
+                    obj.EntityName = name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
+                    obj.Fields = fieldsByID.get(objectIDs[i]) ?? undefined;
+                    return obj;
+                });
+                const { schemaOutput, rsuInput } = await this.buildSchemaForConnector(connInput.CompanyIntegrationID, objects, validatedPlatform, user, skipGitCommit, skipRestart);
+                // Build per-object field map for pending file
+                const sourceObjectFields = {};
+                for (const so of connInput.SourceObjects) {
+                    const resolvedName = resolvedNames[objectIDs.indexOf(so.SourceObjectID)];
+                    if (resolvedName)
+                        sourceObjectFields[resolvedName] = so.Fields ?? null;
+                }
+                // Inject post-restart pending work payload
+                const { join } = await import('node:path');
+                const rsuWorkDir = process.env.RSU_WORK_DIR || process.cwd();
+                const pendingWorkDir = join(rsuWorkDir, '.rsu_pending');
+                const pendingFilePath = join(pendingWorkDir, `${Date.now()}_${connInput.CompanyIntegrationID}.json`);
+                const pendingPayload = {
+                    CompanyIntegrationID: connInput.CompanyIntegrationID,
+                    SourceObjectNames: resolvedNames,
+                    SourceObjectFields: sourceObjectFields,
+                    SchemaName: schemaName,
+                    CronExpression: connInput.CronExpression,
+                    ScheduleTimezone: connInput.ScheduleTimezone,
+                    StartSync: input.StartSync,
+                    FullSync: input.FullSync ?? false,
+                    SyncScope: input.SyncScope ?? 'created',
+                    CreatedAt: new Date().toISOString(),
+                };
+                rsuInput.PostRestartFiles = [
+                    { Path: pendingFilePath, Content: JSON.stringify(pendingPayload, null, 2) }
+                ];
+                return {
+                    connInput,
+                    connector,
+                    companyIntegration,
+                    schemaName,
+                    objects,
+                    schemaOutput,
+                    rsuInput,
+                    pendingFilePath,
+                };
+            }));
+            // Separate successes and failures
+            const successfulBuilds = [];
+            const connectorResults = [];
+            for (let i = 0; i < buildResults.length; i++) {
+                const result = buildResults[i];
+                const connInput = input.Connectors[i];
+                if (result.status === 'fulfilled') {
+                    successfulBuilds.push(result.value);
+                }
+                else {
+                    LogError(`IntegrationApplyAllBatch: build failed for ${connInput.CompanyIntegrationID}: ${result.reason}`);
+                    connectorResults.push({
+                        CompanyIntegrationID: connInput.CompanyIntegrationID,
+                        IntegrationName: 'Unknown',
+                        Success: false,
+                        Message: result.reason instanceof Error ? result.reason.message : String(result.reason),
+                    });
+                }
+            }
+            if (successfulBuilds.length === 0) {
                 return {
                     Success: false,
-                    Message: 'This connector does not provide a default configuration'
+                    Message: 'All connectors failed during schema build phase',
+                    ConnectorResults: connectorResults,
+                    SuccessCount: 0,
+                    FailureCount: connectorResults.length,
+                };
+            }
+            // Phase 2: Run all successful RSU inputs through one pipeline batch
+            const pipelineInputs = successfulBuilds.map(b => b.rsuInput);
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch(pipelineInputs);
+            // Phase 3: Post-pipeline — create entity maps, field maps, schedules for each success
+            for (let i = 0; i < successfulBuilds.length; i++) {
+                const build = successfulBuilds[i];
+                const pipelineResult = batchResult.Results[i];
+                const integrationName = build.companyIntegration.Integration;
+                if (!pipelineResult || !pipelineResult.Success) {
+                    connectorResults.push({
+                        CompanyIntegrationID: build.connInput.CompanyIntegrationID,
+                        IntegrationName: integrationName,
+                        Success: false,
+                        Message: pipelineResult?.ErrorMessage ?? 'Pipeline failed',
+                        Warnings: build.schemaOutput.Warnings.length > 0 ? build.schemaOutput.Warnings : undefined,
+                    });
+                    // Clean up pending file on failure
+                    try {
+                        (await import('node:fs')).unlinkSync(build.pendingFilePath);
+                    }
+                    catch { /* may not exist */ }
+                    continue;
+                }
+                const connResult = {
+                    CompanyIntegrationID: build.connInput.CompanyIntegrationID,
+                    IntegrationName: integrationName,
+                    Success: true,
+                    Message: `Applied ${build.objects.length} object(s)`,
+                    Warnings: build.schemaOutput.Warnings.length > 0 ? build.schemaOutput.Warnings : undefined,
                 };
+                if (skipRestart) {
+                    // Entity maps, field maps, sync
+                    await Metadata.Provider.Refresh();
+                    const entityMapsCreated = await this.createEntityAndFieldMaps(build.connInput.CompanyIntegrationID, build.objects, build.connector, build.companyIntegration, build.schemaName, user);
+                    connResult.EntityMapsCreated = entityMapsCreated;
+                    const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
+                    const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
+                    const syncRunID = input.StartSync !== false
+                        ? await this.startSyncAfterApply(build.connInput.CompanyIntegrationID, user, scopedMapIDs, input.FullSync)
+                        : null;
+                    if (syncRunID)
+                        connResult.SyncRunID = syncRunID;
+                    // Create schedule if CronExpression provided
+                    if (build.connInput.CronExpression) {
+                        const scheduleResult = await this.createScheduleForConnector(build.connInput.CompanyIntegrationID, integrationName, build.connInput.CronExpression, build.connInput.ScheduleTimezone, user);
+                        if (scheduleResult)
+                            connResult.ScheduledJobID = scheduleResult;
+                    }
+                    // Clean up pending file
+                    try {
+                        (await import('node:fs')).unlinkSync(build.pendingFilePath);
+                    }
+                    catch { /* already consumed */ }
+                    connResult.Message = `Applied ${build.objects.length} object(s) — ${entityMapsCreated.length} entity maps created${syncRunID ? ', sync started' : ''}`;
+                }
+                connectorResults.push(connResult);
             }
+            const pipelineSteps = batchResult.Results[0]?.Steps.map((s) => ({
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+            }));
+            const successCount = connectorResults.filter(r => r.Success).length;
+            const failureCount = connectorResults.filter(r => !r.Success).length;
             return {
-                Success: true,
-                Message: `Default configuration with ${config.DefaultObjects.length} objects`,
-                DefaultSchemaName: config.DefaultSchemaName,
-                DefaultObjects: config.DefaultObjects.map(o => ({
-                    SourceObjectName: o.SourceObjectName,
-                    TargetTableName: o.TargetTableName,
-                    TargetEntityName: o.TargetEntityName,
-                    SyncEnabled: o.SyncEnabled,
-                    FieldMappings: o.FieldMappings.map(f => ({
-                        SourceFieldName: f.SourceFieldName,
-                        DestinationFieldName: f.DestinationFieldName,
-                        IsKeyField: f.IsKeyField
-                    }))
-                }))
+                Success: successCount > 0,
+                Message: `Batch complete: ${successCount} succeeded, ${failureCount} failed`,
+                ConnectorResults: connectorResults,
+                PipelineSteps: pipelineSteps,
+                GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                APIRestarted: batchResult.Results[0]?.APIRestarted,
+                SuccessCount: successCount,
+                FailureCount: failureCount,
             };
         }
         catch (e) {
-            const error = e;
-            LogError(`IntegrationGetDefaultConfig error: ${error}`);
+            LogError(`IntegrationApplyAllBatch error: ${e}`);
             return {
-                Success: false,
-                Message: `Error: ${error.message}`
+                Success: false, Message: this.formatError(e),
+                ConnectorResults: [], SuccessCount: 0, FailureCount: 0,
             };
         }
     }
+    /** Helper: creates a schedule for a connector, returns ScheduledJobID or null. */
+    async createScheduleForConnector(companyIntegrationID, integrationName, cronExpression, timezone, user) {
+        try {
+            const md = new Metadata();
+            const rv = new RunView();
+            // Find IntegrationSync job type
+            const jobTypeResult = await rv.RunView({
+                EntityName: 'MJ: Scheduled Job Types',
+                ExtraFilter: `DriverClass='IntegrationSyncScheduledJobDriver'`,
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID']
+            }, user);
+            if (!jobTypeResult.Success || jobTypeResult.Results.length === 0) {
+                LogError('IntegrationApplyAllBatch: IntegrationSync scheduled job type not found');
+                return null;
+            }
+            const jobTypeID = jobTypeResult.Results[0].ID;
+            const job = await md.GetEntityObject('MJ: Scheduled Jobs', user);
+            job.NewRecord();
+            job.JobTypeID = jobTypeID;
+            job.Name = `${integrationName} Sync`;
+            job.CronExpression = cronExpression;
+            job.Timezone = timezone || 'UTC';
+            job.Status = 'Active';
+            job.OwnerUserID = user.ID;
+            job.Configuration = JSON.stringify({ CompanyIntegrationID: companyIntegrationID });
+            if (!await job.Save())
+                return null;
+            // Link to CompanyIntegration
+            const ci = await md.GetEntityObject('MJ: Company Integrations', user);
+            const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (ciLoaded) {
+                ci.ScheduleEnabled = true;
+                ci.ScheduleType = 'Cron';
+                ci.CronExpression = cronExpression;
+                await ci.Save();
+            }
+            return job.ID;
+        }
+        catch (e) {
+            LogError(`IntegrationApplyAllBatch: schedule creation failed: ${this.formatError(e)}`);
+            return null;
+        }
+    }
+    // ── DELETE CONNECTION ────────────────────────────────────────────────
     /**
-     * Generates a DDL preview for creating tables from discovered external objects.
-     * Introspects the source schema and runs SchemaBuilder to produce migration SQL.
+     * Hard-deletes a CompanyIntegration and all associated entity maps, field maps,
+     * and scheduled jobs. Does NOT drop database tables (flagged for future).
      */
-    async IntegrationSchemaPreview(companyIntegrationID, objects, platform, ctx) {
+    async IntegrationDeleteConnection(companyIntegrationID, deleteData, ctx) {
+        try {
+            this.getAuthenticatedUser(ctx); // verify caller is authenticated
+            const sysUser = this.getSystemUser(); // use system user for cascade delete
+            const md = new Metadata();
+            const rv = new RunView();
+            // Step 1: Load CompanyIntegration
+            const ci = await md.GetEntityObject('MJ: Company Integrations', sysUser);
+            const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!ciLoaded)
+                return { Success: false, Message: 'CompanyIntegration not found' };
+            // Cascade delete in FK-safe order using TransactionGroup
+            const tg = await Metadata.Provider.CreateTransactionGroup();
+            let fieldMapsDeleted = 0;
+            let entityMapsDeleted = 0;
+            let schedulesDeleted = 0;
+            // Step 2: Null out ScheduledJobRunID on CompanyIntegrationRuns (break FK before deleting job runs)
+            const ciRunsResult = await rv.RunView({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            if (ciRunsResult.Success) {
+                for (const ciRun of ciRunsResult.Results) {
+                    if (ciRun.ScheduledJobRunID) {
+                        ciRun.ScheduledJobRunID = null;
+                        await ciRun.Save();
+                    }
+                }
+            }
+            // Step 3: Delete scheduled job runs + jobs (reference CI via Configuration JSON)
+            const jobsResult = await rv.RunView({
+                EntityName: 'MJ: Scheduled Jobs',
+                ExtraFilter: `Configuration LIKE '%${companyIntegrationID}%'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            if (jobsResult.Success) {
+                for (const job of jobsResult.Results) {
+                    try {
+                        const config = JSON.parse(job.Configuration || '{}');
+                        if (config.CompanyIntegrationID === companyIntegrationID) {
+                            const jobRunsResult = await rv.RunView({
+                                EntityName: 'MJ: Scheduled Job Runs',
+                                ExtraFilter: `ScheduledJobID='${job.ID}'`,
+                                ResultType: 'entity_object'
+                            }, sysUser);
+                            if (jobRunsResult.Success) {
+                                for (const jr of jobRunsResult.Results) {
+                                    jr.TransactionGroup = tg;
+                                    await jr.Delete();
+                                }
+                            }
+                            job.TransactionGroup = tg;
+                            await job.Delete();
+                            schedulesDeleted++;
+                        }
+                    }
+                    catch { /* skip invalid config */ }
+                }
+            }
+            // Step 4: Delete run details then runs (reuse ciRunsResult from Step 2)
+            if (ciRunsResult.Success) {
+                for (const run of ciRunsResult.Results) {
+                    // Delete run details first
+                    const detailsResult = await rv.RunView({
+                        EntityName: 'MJ: Company Integration Run Details',
+                        ExtraFilter: `CompanyIntegrationRunID='${run.ID}'`,
+                        ResultType: 'entity_object'
+                    }, sysUser);
+                    if (detailsResult.Success) {
+                        for (const detail of detailsResult.Results) {
+                            detail.TransactionGroup = tg;
+                            await detail.Delete();
+                        }
+                    }
+                    run.TransactionGroup = tg;
+                    await run.Delete();
+                }
+            }
+            // Step 4: Delete entity map children (field maps, watermarks, record maps)
+            const entityMapsResult = await rv.RunView({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            const entityMaps = entityMapsResult.Success ? entityMapsResult.Results : [];
+            for (const em of entityMaps) {
+                const fmResult = await rv.RunView({
+                    EntityName: 'MJ: Company Integration Field Maps',
+                    ExtraFilter: `EntityMapID='${em.ID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (fmResult.Success) {
+                    for (const fm of fmResult.Results) {
+                        fm.TransactionGroup = tg;
+                        if (await fm.Delete())
+                            fieldMapsDeleted++;
+                    }
+                }
+                const wmResult = await rv.RunView({
+                    EntityName: 'MJ: Company Integration Sync Watermarks',
+                    ExtraFilter: `EntityMapID='${em.ID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (wmResult.Success) {
+                    for (const wm of wmResult.Results) {
+                        wm.TransactionGroup = tg;
+                        await wm.Delete();
+                    }
+                }
+                const rmResult = await rv.RunView({
+                    EntityName: 'MJ: Company Integration Record Maps',
+                    ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (rmResult.Success) {
+                    for (const rm of rmResult.Results) {
+                        rm.TransactionGroup = tg;
+                        await rm.Delete();
+                    }
+                }
+            }
+            // Step 5: Delete entity maps
+            for (const em of entityMaps) {
+                em.TransactionGroup = tg;
+                if (await em.Delete())
+                    entityMapsDeleted++;
+            }
+            // Step 6: Delete employee-company integration links
+            const empResult = await rv.RunView({
+                EntityName: 'MJ: Employee Company Integrations',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            if (empResult.Success) {
+                for (const emp of empResult.Results) {
+                    emp.TransactionGroup = tg;
+                    await emp.Delete();
+                }
+            }
+            // Step 7: Delete the CompanyIntegration itself
+            ci.TransactionGroup = tg;
+            await ci.Delete();
+            // Submit the transaction
+            const submitted = await tg.Submit();
+            if (!submitted) {
+                return { Success: false, Message: 'Transaction failed — all deletes rolled back' };
+            }
+            if (deleteData) {
+                LogError(`IntegrationDeleteConnection: deleteData=true requested but table deletion not yet implemented for ${companyIntegrationID}`);
+            }
+            return {
+                Success: true,
+                Message: `Deleted connection and all associated records`,
+                EntityMapsDeleted: entityMapsDeleted,
+                FieldMapsDeleted: fieldMapsDeleted,
+                SchedulesDeleted: schedulesDeleted,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationDeleteConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    // ── SCHEMA EVOLUTION ────────────────────────────────────────────────
+    /**
+     * Detects schema changes (new/modified columns) in the external system and
+     * applies ALTER TABLE migrations via the RSU pipeline.
+     * Compares the current connector introspection against existing MJ entities.
+     */
+    async IntegrationSchemaEvolution(companyIntegrationID, platform, skipGitCommit, skipRestart, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
             const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
-            // Introspect schema from the external system
+            const schemaName = this.deriveSchemaName(companyIntegration.Integration);
+            const md = new Metadata();
+            const rv = new RunView();
+            // Step 1: Get existing entity maps for this CompanyIntegration
+            const entityMapsResult = await rv.RunView({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'simple',
+                Fields: ['ID', 'ExternalObjectName', 'EntityID']
+            }, user);
+            if (!entityMapsResult.Success || entityMapsResult.Results.length === 0) {
+                return {
+                    Success: false, Message: 'No entity maps found — nothing to evolve',
+                    HasChanges: false,
+                };
+            }
+            const sourceObjectNames = entityMapsResult.Results.map(em => em.ExternalObjectName);
+            const objects = this.buildObjectInputsFromNames(sourceObjectNames, schemaName);
+            // Step 2: Build ExistingTables from Metadata.Entities matching the schema
+            const existingTables = [];
+            for (const obj of objects) {
+                const entityInfo = md.Entities.find(e => e.SchemaName.toLowerCase() === schemaName.toLowerCase()
+                    && e.BaseTable.toLowerCase() === obj.TableName.toLowerCase());
+                if (entityInfo) {
+                    existingTables.push({
+                        SchemaName: entityInfo.SchemaName,
+                        TableName: entityInfo.BaseTable,
+                        Columns: entityInfo.Fields.map(f => ({
+                            Name: f.Name,
+                            SqlType: f.SQLFullType || f.Type,
+                            IsNullable: f.AllowsNull,
+                            MaxLength: f.MaxLength > 0 ? f.MaxLength : null,
+                            Precision: f.Precision > 0 ? f.Precision : null,
+                            Scale: f.Scale > 0 ? f.Scale : null,
+                        })),
+                    });
+                }
+            }
+            // Step 3: Introspect current schema from connector
             const introspect = connector.IntrospectSchema.bind(connector);
             const sourceSchema = await introspect(companyIntegration, user);
-            // Filter to only requested objects
-            const requestedNames = new Set(objects.map(o => o.SourceObjectName));
+            // Normalize names to match source schema casing
+            const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+            const normalizedNames = sourceObjectNames.map(n => nameMap.get(n.toLowerCase()) ?? n);
+            // Also normalize the objects array SourceObjectName
+            for (const obj of objects) {
+                const exact = nameMap.get(obj.SourceObjectName.toLowerCase());
+                if (exact)
+                    obj.SourceObjectName = exact;
+            }
+            const requestedNames = new Set(normalizedNames);
             const filteredSchema = {
                 Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
             };
-            // Build target configs from user input + source schema
-            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, platform);
-            // Run SchemaBuilder
-            const input = {
+            // Step 4: Build target configs and SchemaBuilder input with ExistingTables
+            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, validatedPlatform, connector);
+            const schemaInput = {
                 SourceSchema: filteredSchema,
                 TargetConfigs: targetConfigs,
-                Platform: platform,
-                MJVersion: '5.7.0',
+                Platform: validatedPlatform,
+                MJVersion: process.env.MJ_VERSION ?? '5.11.0',
                 SourceType: companyIntegration.Integration,
-                AdditionalSchemaInfoPath: 'additionalSchemaInfo.json',
-                MigrationsDir: 'migrations/v2',
-                MetadataDir: 'metadata',
-                ExistingTables: [],
+                AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+                MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+                MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+                ExistingTables: existingTables,
                 EntitySettingsForTargets: {}
             };
+            // Step 5: Build schema — SchemaBuilder handles evolution (ALTER TABLE) internally
             const builder = new SchemaBuilder();
-            const output = builder.BuildSchema(input);
-            if (output.Errors.length > 0) {
+            const schemaOutput = builder.BuildSchema(schemaInput);
+            if (schemaOutput.Errors.length > 0) {
                 return {
                     Success: false,
-                    Message: `Schema generation failed: ${output.Errors.join('; ')}`,
-                    Warnings: output.Warnings
+                    Message: `Schema evolution failed: ${schemaOutput.Errors.join('; ')}`,
+                    HasChanges: false,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
                 };
             }
-            const allFiles = [
-                ...output.MigrationFiles,
-                ...(output.AdditionalSchemaInfoUpdate ? [output.AdditionalSchemaInfoUpdate] : []),
-                ...output.MetadataFiles
-            ];
+            // Step 6: Check if any migration SQL was generated
+            if (schemaOutput.MigrationFiles.length === 0) {
+                return {
+                    Success: true,
+                    Message: 'No schema changes detected',
+                    HasChanges: false,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+            // Step 7: Count added/modified columns by re-diffing
+            let addedColumns = 0;
+            let modifiedColumns = 0;
+            const evolution = new SchemaEvolution();
+            for (const existing of existingTables) {
+                const config = targetConfigs.find(c => c.SchemaName.toLowerCase() === existing.SchemaName.toLowerCase()
+                    && c.TableName.toLowerCase() === existing.TableName.toLowerCase());
+                if (!config)
+                    continue;
+                const sourceObj = filteredSchema.Objects.find(o => o.ExternalName.toLowerCase() === config.SourceObjectName.toLowerCase());
+                if (!sourceObj)
+                    continue;
+                const diff = evolution.DiffSchema(sourceObj, config, existing, validatedPlatform);
+                addedColumns += diff.AddedColumns.length;
+                modifiedColumns += diff.ModifiedColumns.length;
+            }
+            // Step 8: Run RSU pipeline
+            const rsuInput = builder.BuildRSUInput(schemaOutput, schemaInput, {
+                SkipGitCommit: skipGitCommit,
+                SkipRestart: skipRestart,
+            });
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch([rsuInput]);
+            const pipelineResult = batchResult.Results[0];
+            const pipelineSteps = pipelineResult?.Steps.map((s) => ({
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+            }));
             return {
-                Success: true,
-                Message: `Generated ${allFiles.length} files`,
-                Files: allFiles.map(f => ({
-                    FilePath: f.FilePath,
-                    Content: f.Content,
-                    Description: f.Description
-                })),
-                Warnings: output.Warnings.length > 0 ? output.Warnings : undefined
+                Success: pipelineResult?.Success ?? false,
+                Message: pipelineResult?.Success
+                    ? `Schema evolution applied — ${addedColumns} column(s) added, ${modifiedColumns} column(s) modified`
+                    : `Pipeline failed: ${pipelineResult?.ErrorMessage ?? 'unknown error'}`,
+                HasChanges: true,
+                AddedColumns: addedColumns,
+                ModifiedColumns: modifiedColumns,
+                Steps: pipelineSteps,
+                GitCommitSuccess: pipelineResult?.GitCommitSuccess,
+                APIRestarted: pipelineResult?.APIRestarted,
+                Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
             };
         }
         catch (e) {
-            const error = e;
-            LogError(`IntegrationSchemaPreview error: ${error}`);
-            return {
-                Success: false,
-                Message: `Error: ${error.message}`
-            };
+            LogError(`IntegrationSchemaEvolution error: ${e}`);
+            return { Success: false, Message: this.formatError(e), HasChanges: false };
         }
     }
-    /**
-     * Fetches a small sample of records from an external object for preview purposes.
-     * Uses the connector's FetchChanges with a small batch size and no watermark.
-     */
-    async IntegrationPreviewData(companyIntegrationID, objectName, limit, ctx) {
+    // ── WEBHOOK HELPER ──────────────────────────────────────────────────
+    async sendWebhook(url, payload) {
         try {
-            const user = this.getAuthenticatedUser(ctx);
-            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
-            const fetchChanges = connector.FetchChanges.bind(connector);
-            const result = await fetchChanges({
-                CompanyIntegration: companyIntegration,
-                ObjectName: objectName,
-                WatermarkValue: null,
-                BatchSize: Math.min(limit, 10),
-                ContextUser: user
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
             });
-            return {
-                Success: true,
-                Message: `Fetched ${result.Records.length} preview records`,
-                Records: result.Records.map(r => ({
-                    Data: JSON.stringify(r.Fields)
-                }))
-            };
+            if (!response.ok) {
+                console.error(`[Integration] Webhook POST to ${url} returned ${response.status}`);
+            }
         }
         catch (e) {
-            const error = e;
-            LogError(`IntegrationPreviewData error: ${error}`);
-            return {
-                Success: false,
-                Message: `Error: ${error.message}`
-            };
-        }
-    }
-    // --- Private Helpers ---
-    buildTargetConfigs(objects, sourceSchema, platform) {
-        const mapper = new TypeMapper();
-        return objects.map(obj => {
-            const sourceObj = sourceSchema.Objects.find(o => o.ExternalName === obj.SourceObjectName);
-            const columns = (sourceObj?.Fields ?? []).map(f => ({
-                SourceFieldName: f.Name,
-                TargetColumnName: f.Name.replace(/[^A-Za-z0-9_]/g, '_'),
-                TargetSqlType: mapper.MapSourceType(f.SourceType, platform, f),
-                IsNullable: !f.IsRequired,
-                MaxLength: f.MaxLength,
-                Precision: f.Precision,
-                Scale: f.Scale,
-                DefaultValue: f.DefaultValue
-            }));
-            const primaryKeyFields = (sourceObj?.Fields ?? [])
-                .filter(f => f.IsPrimaryKey)
-                .map(f => f.Name.replace(/[^A-Za-z0-9_]/g, '_'));
-            return {
-                SourceObjectName: obj.SourceObjectName,
-                SchemaName: obj.SchemaName,
-                TableName: obj.TableName,
-                EntityName: obj.EntityName,
-                Columns: columns,
-                PrimaryKeyFields: primaryKeyFields.length > 0 ? primaryKeyFields : ['ID'],
-                SoftForeignKeys: []
-            };
-        });
-    }
-    getAuthenticatedUser(ctx) {
-        const user = ctx.userPayload.userRecord;
-        if (!user) {
-            throw new Error("User is not authenticated");
-        }
-        return user;
-    }
-    /**
-     * Loads the CompanyIntegration + its parent Integration, then resolves the
-     * appropriate connector via ConnectorFactory.
-     *
-     * NOTE: Entity objects loaded here come from the MJServer's copy of core-entities.
-     * The integration-engine package may resolve its own copy of core-entities, causing
-     * TypeScript nominal type mismatches. At runtime the objects are structurally identical,
-     * so we cast through `unknown` at the boundary calls.
-     */
-    async resolveConnector(companyIntegrationID, contextUser) {
-        const md = new Metadata();
-        // Load the CompanyIntegration record
-        const companyIntegration = await md.GetEntityObject('MJ: Company Integrations', contextUser);
-        const loaded = await companyIntegration.Load(companyIntegrationID);
-        if (!loaded) {
-            throw new Error(`CompanyIntegration with ID "${companyIntegrationID}" not found`);
-        }
-        // Load the parent Integration record
-        const integration = await md.GetEntityObject('MJ: Integrations', contextUser);
-        const integrationLoaded = await integration.Load(companyIntegration.IntegrationID);
-        if (!integrationLoaded) {
-            throw new Error(`Integration with ID "${companyIntegration.IntegrationID}" not found`);
+            console.error(`[Integration] Webhook POST to ${url} failed:`, e);
         }
-        // ConnectorFactory expects its own copy of core-entities types — cast through unknown
-        const connector = ConnectorFactory.Resolve(integration);
-        return { connector, companyIntegration };
-    }
-    handleDiscoveryError(e) {
-        const error = e;
-        LogError(`Integration discovery error: ${error}`);
-        return {
-            Success: false,
-            Message: `Error: ${error.message}`
-        };
     }
 };
+__decorate([
+    Query(() => DiscoverConnectorsOutput),
+    __param(0, Arg("companyID", { nullable: true })),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationDiscoverConnectors", null);
 __decorate([
     Query(() => DiscoverObjectsOutput),
     __param(0, Arg("companyIntegrationID")),
@@ -617,7 +3900,263 @@ __decorate([
     __metadata("design:paramtypes", [String, String, Number, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationPreviewData", null);
-IntegrationDiscoveryResolver = __decorate([
+__decorate([
+    Query(() => ListConnectionsOutput),
+    __param(0, Arg("activeOnly", { defaultValue: true })),
+    __param(1, Arg("companyID", { nullable: true })),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean, String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationListConnections", null);
+__decorate([
+    Mutation(() => CreateConnectionOutput),
+    __param(0, Arg("input")),
+    __param(1, Arg("testConnection", () => Boolean, { defaultValue: false })),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateConnectionInput, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationCreateConnection", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("credentialValues", { nullable: true })),
+    __param(2, Arg("configuration", { nullable: true })),
+    __param(3, Arg("externalSystemID", { nullable: true })),
+    __param(4, Arg("testConnection", () => Boolean, { defaultValue: false })),
+    __param(5, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationUpdateConnection", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationDeactivateConnection", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationReactivateConnection", null);
+__decorate([
+    Mutation(() => CreateEntityMapsOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("entityMaps", () => [EntityMapInput])),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationCreateEntityMaps", null);
+__decorate([
+    Mutation(() => ApplySchemaOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("objects", () => [SchemaPreviewObjectInput])),
+    __param(2, Arg("platform", { defaultValue: "sqlserver" })),
+    __param(3, Arg("skipGitCommit", { defaultValue: false })),
+    __param(4, Arg("skipRestart", { defaultValue: false })),
+    __param(5, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, String, Boolean, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationApplySchema", null);
+__decorate([
+    Mutation(() => ApplySchemaBatchOutput),
+    __param(0, Arg("items", () => [ApplySchemaBatchItemInput])),
+    __param(1, Arg("platform", { defaultValue: "sqlserver" })),
+    __param(2, Arg("skipGitCommit", { defaultValue: false })),
+    __param(3, Arg("skipRestart", { defaultValue: false })),
+    __param(4, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, String, Boolean, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationApplySchemaBatch", null);
+__decorate([
+    Mutation(() => ApplyAllOutput),
+    __param(0, Arg("input")),
+    __param(1, Arg("platform", { defaultValue: "sqlserver" })),
+    __param(2, Arg("skipGitCommit", { defaultValue: false })),
+    __param(3, Arg("skipRestart", { defaultValue: false })),
+    __param(4, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ApplyAllInput, String, Boolean, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationApplyAll", null);
+__decorate([
+    Mutation(() => StartSyncOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("webhookURL", { nullable: true })),
+    __param(2, Arg("fullSync", () => Boolean, { defaultValue: false, description: 'If true, ignores watermarks and re-fetches all records from the source' })),
+    __param(3, Arg("entityMapIDs", () => [String], { nullable: true, description: 'Optional: sync only these entity maps. If omitted, syncs all maps for the connector.' })),
+    __param(4, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Boolean, Array, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationStartSync", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationCancelSync", null);
+__decorate([
+    Mutation(() => CreateScheduleOutput),
+    __param(0, Arg("input")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateScheduleInput, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationCreateSchedule", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("scheduledJobID")),
+    __param(1, Arg("cronExpression", { nullable: true })),
+    __param(2, Arg("timezone", { nullable: true })),
+    __param(3, Arg("name", { nullable: true })),
+    __param(4, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationUpdateSchedule", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("scheduledJobID")),
+    __param(1, Arg("enabled", () => Boolean)),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationToggleSchedule", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("scheduledJobID")),
+    __param(1, Arg("companyIntegrationID", { nullable: true })),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationDeleteSchedule", null);
+__decorate([
+    Query(() => ListSchedulesOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationListSchedules", null);
+__decorate([
+    Query(() => ListEntityMapsOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationListEntityMaps", null);
+__decorate([
+    Query(() => ListFieldMapsOutput),
+    __param(0, Arg("entityMapID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationListFieldMaps", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("updates", () => [EntityMapUpdateInput])),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationUpdateEntityMaps", null);
+__decorate([
+    Mutation(() => MutationResultOutput),
+    __param(0, Arg("entityMapIDs", () => [String])),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationDeleteEntityMaps", null);
+__decorate([
+    Query(() => OperationProgressOutput),
+    __param(0, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationGetRSUProgress", null);
+__decorate([
+    Query(() => OperationProgressOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationGetSyncProgress", null);
+__decorate([
+    Query(() => IntegrationStatusOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationGetStatus", null);
+__decorate([
+    Query(() => SyncHistoryOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("limit", { defaultValue: 20 })),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationGetSyncHistory", null);
+__decorate([
+    Query(() => ConnectorCapabilitiesOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationGetConnectorCapabilities", null);
+__decorate([
+    Mutation(() => ApplyAllBatchOutput),
+    __param(0, Arg("input")),
+    __param(1, Arg("platform", { defaultValue: "sqlserver" })),
+    __param(2, Arg("skipGitCommit", { defaultValue: false })),
+    __param(3, Arg("skipRestart", { defaultValue: false })),
+    __param(4, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ApplyAllBatchInput, String, Boolean, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationApplyAllBatch", null);
+__decorate([
+    Mutation(() => DeleteConnectionOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("deleteData", { defaultValue: false })),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationDeleteConnection", null);
+__decorate([
+    Mutation(() => SchemaEvolutionOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("platform", { defaultValue: "sqlserver" })),
+    __param(2, Arg("skipGitCommit", { defaultValue: false })),
+    __param(3, Arg("skipRestart", { defaultValue: false })),
+    __param(4, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Boolean, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationSchemaEvolution", null);
+IntegrationDiscoveryResolver = IntegrationDiscoveryResolver_1 = __decorate([
     Resolver()
 ], IntegrationDiscoveryResolver);
 export { IntegrationDiscoveryResolver };