@memberjunction/integration-connectors 5.41.0 → 5.43.0

package/dist/IMISConnector.js

@@ -4,15 +4,66 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+/**
+ * IMISConnector — Integration connector for iMIS EMS (Advanced Solutions International)
+ * REST API.
+ *
+ * ── Auth: OAuth 2.0 PASSWORD grant (resource-owner) ─────────────────────────
+ *   Mints/refreshes a bearer ACCESS TOKEN via the shared {@link OAuth2TokenManager}
+ *   (no inlined token/crypto logic). iMIS issues tokens via the resource-owner
+ *   `grant_type=password` flow — username + password POSTed to the token endpoint:
+ *     - default  = `{BaseURL}/token`
+ *     - override  = the credential's `TokenURL` (when supplied)
+ *     - fallback  = the legacy `{BaseURL}/asiScheduler/token` path (older iMIS builds)
+ *   iMIS does NOT require client_id/client_secret for the password grant, so the
+ *   OAuth2TokenManager request is configured with empty client credentials in the
+ *   body. Every API request sends `Authorization: Bearer {accessToken}`.
+ *
+ * ── Base URL ────────────────────────────────────────────────────────────────
+ *   Comes from the credential's `BaseURL` (the tenant's iMIS API endpoint) — never
+ *   a hardcoded host. Credential bytes are resolved at runtime, never at build.
+ *
+ * ── Catalog (metadata-driven, NOT hardcoded) ───────────────────────────────
+ *   The Declared core object/field set comes from the seeded metadata loaded into
+ *   the IntegrationEngineBase cache. The connector NEVER bakes an object/field catalog
+ *   into code. DiscoverObjects/DiscoverFields express only the MECHANISM: they call the
+ *   auth-gated /EntityDefinition + /{entity}/metadata endpoints at runtime to enumerate
+ *   the tenant's Business-Object catalog + per-object fields, ADDITIVE to the Declared
+ *   baseline. DiscoveryIsAuthoritative stays false (default) — these scoped enumerations
+ *   never deactivate Declared metadata on absence.
+ *
+ * ── Pagination & incremental ───────────────────────────────────────────────
+ *   iMIS uses the PagedResult envelope (`{ Items, Offset, Limit, Count, HasNext }`) with
+ *   capitalized `Offset`/`Limit` query params; ExtractPaginationInfo reads HasNext/Offset/Limit
+ *   and advances Offset by the returned count until HasNext is false. NormalizeResponse
+ *   unwraps the Items collection. Incremental sync is metadata-driven: an IO with
+ *   SupportsIncrementalSync=true emits its `IncrementalWatermarkField` as a `gt:` filter.
+ *
+ * ── Write ───────────────────────────────────────────────────────────────────
+ *   CRUD rides the generic BaseRESTIntegrationConnector per-operation path: Create/Update/Delete
+ *   read the per-operation IO columns (CreateAPIPath/Method/BodyShape/BodyKey/IDLocation, Update*,
+ *   Delete*), creates route through BuildCreatedResult (fail loudly on empty ID), and DeleteMethod
+ *   is metadata-driven (not assumed DELETE). Capability flags follow the per-operation columns the
+ *   metadata declares — no hardcoded `true`, no 501 stubs. Full-record pass-through (Fields=raw).
+ *
+ * Reference: https://developer.imis.com/docs/imis-rest-api-data-models-and-swagger-json-files
+ */
 import { RegisterClass } from '@memberjunction/global';
 import { Metadata } from '@memberjunction/core';
-import { BaseIntegrationConnector, BaseRESTIntegrationConnector, } from '@memberjunction/integration-engine';
-// ─── Constants ─────────────────────────────────────────────────────────
+import { BaseIntegrationConnector, BaseRESTIntegrationConnector, OAuth2TokenManager, } from '@memberjunction/integration-engine';
+import { IntegrationEngineBase } from '@memberjunction/integration-engine-base';
+// ─── Constants ───────────────────────────────────────────────────────
+/** The canonical MJ: Integrations.Name — part of the three-way invariant. */
+const INTEGRATION_NAME = 'iMIS';
+/** Default token endpoint path appended to the base when no TokenURL override is supplied. */
+const DEFAULT_TOKEN_PATH = '/token';
+/** Legacy token endpoint path for older iMIS deployments (documented fallback). */
+const LEGACY_TOKEN_PATH = '/asiScheduler/token';
 const DEFAULT_MAX_RETRIES = 3;
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 const DEFAULT_MIN_REQUEST_INTERVAL_MS = 200;
-const TOKEN_REFRESH_BUFFER_MS = 60_000;
-/** iMIS-to-SQL type mapping used when merging live-discovered field metadata. */
+const DEFAULT_PAGE_SIZE = 100;
+/** iMIS-to-generic type mapping used when merging live-discovered field metadata. */
 const IMIS_TYPE_MAP = {
     'string': 'string',
     'datetime': 'datetime',
@@ -29,87 +80,141 @@ const IMIS_TYPE_MAP = {
     'uuid': 'uuid',
     'monetaryamountdata': 'decimal',
 };
-// ─── Connector ─────────────────────────────────────────────────────────
-/**
- * Connector for iMIS EMS (Advanced Solutions International) REST API.
- *
- * Extends BaseRESTIntegrationConnector so the generic metadata-driven fetch
- * loop handles pagination, template variables, and record normalization.
- * Adds iMIS-specific:
- *   - OAuth 2.0 Password Grant / SSO refresh-token authentication
- *   - /{entity}/metadata runtime field discovery (merged with static IntegrationObjectField metadata, IsCustom=true)
- *   - /BOEntityDefinition runtime object discovery (customer Business Objects, IsCustom=true)
- *   - PagedResult envelope with Offset/Limit + HasNext flag
- *   - UpdatedOn=gt:&lt;iso-date&gt; watermark filter for incremental sync
- *   - PUT (full replace) for updates with automatic read-modify-write merge
- *
- * Reference: https://developer.imis.com/docs/imis-rest-api-data-models-and-swagger-json-files
- */
+// ─── Connector Implementation ────────────────────────────────────────
 let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
     constructor() {
         super(...arguments);
-        this.authState = null;
+        /** Cached auth context for the current sync run. */
+        this.authCache = null;
+        /** Shared OAuth2 token manager — owns the token round-trip + cache. */
+        this.tokenManager = new OAuth2TokenManager();
+        /** Timestamp of the last API request, for client-side throttling. */
         this.lastRequestTime = 0;
-        /** Current watermark for the in-flight FetchChanges — used by AppendDefaultQueryParams */
-        this.currentWatermark = null;
     }
-    // ── Capability flags ────────────────────────────────────────────
-    get SupportsCreate() { return true; }
-    get SupportsUpdate() { return true; }
-    get SupportsDelete() { return true; }
+    // Returns the EXACT MJ: Integrations.Name string LITERAL so the T1 ThreeWayName invariant can
+    // statically parse the getter's returned value from connector source.
+    get IntegrationName() { return 'iMIS'; }
+    // ── Capability getters: METADATA-DRIVEN (no hardcoded answer) ─────
+    //
+    // Write capability FOLLOWS the per-operation CRUD columns on the cached IntegrationObjects
+    // (Declared metadata). An object is create-capable when it declares both CreateAPIPath +
+    // CreateMethod; same for update/delete. With no write metadata authored the surface is
+    // read-only (returns false) — but the moment a writable object's per-operation columns are
+    // populated, the capability flips on and the base generic CRUD path executes it.
+    get SupportsCreate() {
+        return this.anyObjectDeclares(o => !!o.CreateAPIPath && !!o.CreateMethod);
+    }
+    get SupportsUpdate() {
+        return this.anyObjectDeclares(o => !!o.UpdateAPIPath && !!o.UpdateMethod);
+    }
+    get SupportsDelete() {
+        return this.anyObjectDeclares(o => !!o.DeleteAPIPath && !!o.DeleteMethod);
+    }
     get SupportsSearch() { return false; }
     get SupportsListing() { return false; }
-    get IntegrationName() { return 'iMIS'; }
-    // ── Auth + transport (abstract methods from BaseRESTIntegrationConnector) ────
+    /** True when any cached IntegrationObject satisfies the predicate. []→false when the engine
+     *  cache is unavailable (e.g. capability probed before configuration) — fail-safe read-only. */
+    anyObjectDeclares(pred) {
+        const integration = IntegrationEngineBase.Instance.GetIntegrationByName(INTEGRATION_NAME);
+        if (!integration)
+            return false;
+        return IntegrationEngineBase.Instance.GetActiveIntegrationObjects(integration.ID).some(pred);
+    }
+    // ─── BaseRESTIntegrationConnector abstract methods ──────────────
+    /**
+     * OAuth 2.0 password-grant authentication. Mints/refreshes the access token via the shared
+     * {@link OAuth2TokenManager} (no inlined token/crypto logic). One token exchange per run is
+     * cached and reused across every request.
+     */
     async Authenticate(companyIntegration, contextUser) {
-        return this.GetAuth(companyIntegration, contextUser);
+        if (this.authCache)
+            return this.authCache;
+        const config = await this.ParseConfig(companyIntegration, contextUser);
+        const baseUrl = this.ResolveBaseUrl(config);
+        const token = await this.MintToken(config, baseUrl);
+        const auth = { Token: token, BaseUrl: baseUrl, Config: config };
+        this.authCache = auth;
+        return auth;
     }
-    BuildHeaders(auth) {
-        const imisAuth = auth;
+    /**
+     * Runs the password-grant token round-trip through OAuth2TokenManager. Tries the resolved
+     * token endpoint first, then the legacy `/asiScheduler/token` path on failure (older iMIS).
+     */
+    async MintToken(config, baseUrl) {
+        const primaryURL = this.ResolveTokenURL(config, baseUrl);
+        const req = this.BuildTokenRequest(config, primaryURL);
+        try {
+            const token = await this.tokenManager.GetAccessToken(req, 'password');
+            return token.AccessToken;
+        }
+        catch (primaryErr) {
+            // Legacy fallback only when no explicit override was given and the legacy path differs.
+            const legacyURL = `${baseUrl}${LEGACY_TOKEN_PATH}`;
+            if (config.TokenURL || legacyURL === primaryURL)
+                throw primaryErr;
+            this.tokenManager.Reset();
+            const token = await this.tokenManager.GetAccessToken({ ...req, TokenURL: legacyURL }, 'password');
+            return token.AccessToken;
+        }
+    }
+    /** Builds the OAuth2 password-grant request. iMIS does not require client credentials. */
+    BuildTokenRequest(config, tokenURL) {
         return {
-            'Authorization': `Bearer ${imisAuth.Token}`,
-            'Accept': 'application/json',
+            TokenURL: tokenURL,
+            ClientId: config.ClientId ?? '',
+            ClientSecret: config.ClientSecret ?? '',
+            Username: config.Username,
+            Password: config.Password,
+            TimeoutMs: config.RequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
         };
     }
-    async MakeHTTPRequest(auth, url, method, headers, body) {
-        const imisAuth = auth;
-        const maxRetries = imisAuth.Config.MaxRetries ?? DEFAULT_MAX_RETRIES;
-        const timeoutMs = imisAuth.Config.RequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-        const minInterval = imisAuth.Config.MinRequestIntervalMs ?? DEFAULT_MIN_REQUEST_INTERVAL_MS;
-        const effectiveHeaders = { ...headers };
-        if (body !== undefined && !effectiveHeaders['Content-Type']) {
-            effectiveHeaders['Content-Type'] = 'application/json';
-        }
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            await this.Throttle(minInterval);
-            const response = await this.ExecuteFetch(url, method, effectiveHeaders, body, timeoutMs);
-            this.lastRequestTime = Date.now();
-            if (response.status === 401 && attempt < maxRetries) {
-                // Token may have expired mid-request — force refresh and retry once.
-                this.authState = null;
-                const fresh = await this.GetAuth(imisAuth.Config);
-                imisAuth.Token = fresh.Token;
-                imisAuth.ExpiresAt = fresh.ExpiresAt;
-                effectiveHeaders['Authorization'] = `Bearer ${fresh.Token}`;
-                continue;
-            }
-            if (this.ShouldRetry(response.status) && attempt < maxRetries) {
-                const delay = this.ComputeRetryDelay(response, attempt);
-                await this.Sleep(delay);
-                continue;
+    /**
+     * Extracts the new record's external ID from a create response. iMIS returns the created
+     * object with a vendor-specific ID field (Id / PartyId / EventId / InvoiceId / …); the base
+     * scanner only knows the generic `id` family, so widen it for iMIS's `{Object}Id` convention.
+     * The empty-ID case still routes through BuildCreatedResult, which fails loudly.
+     */
+    ExtractIDFromResponse(response, idLocation) {
+        if ((!idLocation || idLocation === 'body') && response.Body && typeof response.Body === 'object') {
+            const b = response.Body;
+            const candidates = ['Id', 'ID', 'PartyId', 'UniformId', 'EventId', 'InvoiceId', 'PaymentId', 'id', 'externalID', 'ExternalID'];
+            for (const k of candidates) {
+                const v = b[k];
+                if (typeof v === 'string' || typeof v === 'number') {
+                    const s = String(v).trim();
+                    if (s.length > 0)
+                        return s;
+                }
             }
-            return this.BuildRESTResponse(response);
+            return undefined;
         }
-        throw new Error(`iMIS API request failed after ${maxRetries} attempt(s): ${url}`);
+        return super.ExtractIDFromResponse(response, idLocation);
     }
+    /** Sends the OAuth2 bearer token on every request. */
+    BuildHeaders(auth) {
+        const token = auth.Token ?? auth.Token ?? '';
+        return {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        };
+    }
+    GetBaseURL(_companyIntegration, auth) {
+        return auth.BaseUrl;
+    }
+    /**
+     * Unwraps the iMIS PagedResult envelope to the Items collection. Handles the envelope,
+     * an explicit responseDataKey, a raw array, and a single-object detail response. The FULL
+     * source record passes through (no field filtering) so the framework's custom-column capture
+     * sees everything the source returned.
+     */
     NormalizeResponse(rawBody, responseDataKey) {
         if (rawBody == null)
             return [];
-        // PagedResult envelope → Items
+        // PagedResult envelope → Items (ResponseDataKey is typically "Items")
         if (this.IsPagedResult(rawBody)) {
             return rawBody.Items ?? [];
         }
-        // Explicit key provided (e.g., "Items")
         if (responseDataKey) {
             const record = rawBody;
             const data = record[responseDataKey];
@@ -118,19 +223,23 @@ let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
         }
         if (Array.isArray(rawBody))
             return rawBody;
-        // Single-object response (e.g., GET /{Entity}/{id})
+        // Single-object detail response (GET /{Entity}/{id}).
         return [rawBody];
     }
-    ExtractPaginationInfo(rawBody, paginationType, currentPage, currentOffset, pageSize) {
+    /**
+     * Derives Offset/Limit pagination state from the iMIS PagedResult envelope: advance Offset by
+     * the number of Items returned and continue while HasNext is true (terminate when HasNext is false).
+     */
+    ExtractPaginationInfo(rawBody, paginationType, currentPage, currentOffset, _pageSize) {
         if (paginationType === 'None')
             return { HasMore: false };
         const envelope = this.IsPagedResult(rawBody) ? rawBody : null;
         if (!envelope) {
-            // Fallback: no PagedResult envelope → no more pages
+            // No PagedResult envelope → cannot advance → no more pages.
             return { HasMore: false };
         }
-        const hasMore = envelope.HasNext ?? false;
         const returnedCount = envelope.Items?.length ?? 0;
+        const hasMore = (envelope.HasNext ?? false) && returnedCount > 0;
         const nextOffset = (envelope.Offset ?? currentOffset) + returnedCount;
         return {
             HasMore: hasMore,
@@ -139,15 +248,12 @@ let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
             TotalRecords: envelope.Count,
         };
     }
-    GetBaseURL(_companyIntegration, auth) {
-        return auth.BaseUrl;
-    }
     /**
-     * iMIS pagination uses `Offset` and `Limit` query parameters (capitalized).
-     * Override the base class helper to match iMIS's param names.
+     * iMIS pagination uses capitalized `Offset` / `Limit` query parameters. Override the base
+     * helper to match iMIS's param names.
      */
     BuildPaginatedURL(basePath, obj, page, offset, cursor, effectivePageSize) {
-        const pageSize = effectivePageSize ?? obj.DefaultPageSize ?? 100;
+        const pageSize = effectivePageSize ?? obj.DefaultPageSize ?? DEFAULT_PAGE_SIZE;
         const separator = basePath.includes('?') ? '&' : '?';
         switch (obj.PaginationType) {
             case 'PageNumber':
@@ -163,156 +269,152 @@ let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
         }
     }
     /**
-     * Inject watermark filter (UpdatedOn=gt:<iso>) when an incremental sync is active.
-     * The iMIS REST API accepts operator-prefixed filter values (`gt:`, `ge:`, `lt:`) on list endpoints.
+     * Injects the incremental watermark filter when a sync is active. The param NAME is fully
+     * METADATA-DRIVEN: it comes from the IO's `IncrementalWatermarkField` and is emitted only when
+     * SupportsIncrementalSync=true AND a watermark value is in context. iMIS accepts operator-prefixed
+     * filter values (`gt:`) on list endpoints.
      */
     AppendDefaultQueryParams(url, obj) {
         let result = super.AppendDefaultQueryParams(url, obj);
-        if (this.currentWatermark && obj.SupportsIncrementalSync) {
+        const watermarkField = obj.IncrementalWatermarkField;
+        if (obj.SupportsIncrementalSync && watermarkField && this.currentWatermark) {
             const separator = result.includes('?') ? '&' : '?';
-            const param = `UpdatedOn=${encodeURIComponent('gt:' + this.currentWatermark)}`;
+            const param = `${encodeURIComponent(watermarkField)}=${encodeURIComponent('gt:' + this.currentWatermark)}`;
             result = `${result}${separator}${param}`;
         }
         return result;
     }
-    // ── Public API: Discovery, FetchChanges, CRUD ───────────────────
+    /** Executes an HTTP request with client-side throttling + retry for 401/429/5xx. */
+    async MakeHTTPRequest(auth, url, method, headers, body) {
+        const imisAuth = auth;
+        const maxRetries = imisAuth.Config.MaxRetries ?? DEFAULT_MAX_RETRIES;
+        const timeoutMs = imisAuth.Config.RequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        const minInterval = imisAuth.Config.MinRequestIntervalMs ?? DEFAULT_MIN_REQUEST_INTERVAL_MS;
+        const effectiveHeaders = { ...headers };
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            await this.ThrottleIfNeeded(minInterval);
+            const fetchOptions = {
+                method,
+                headers: effectiveHeaders,
+                signal: AbortSignal.timeout(timeoutMs),
+            };
+            if (body !== undefined && method !== 'GET') {
+                fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+            }
+            let response;
+            try {
+                response = await fetch(url, fetchOptions);
+            }
+            catch (err) {
+                if (attempt < maxRetries && this.IsTransientNetworkError(err)) {
+                    await this.Sleep(this.BackoffDelay(attempt));
+                    continue;
+                }
+                throw err;
+            }
+            this.lastRequestTime = Date.now();
+            // Token expired mid-run — force a fresh mint and retry once with the new bearer.
+            if (response.status === 401 && attempt < maxRetries) {
+                this.tokenManager.Reset();
+                this.authCache = null;
+                const fresh = await this.MintToken(imisAuth.Config, imisAuth.BaseUrl);
+                imisAuth.Token = fresh;
+                this.authCache = imisAuth;
+                effectiveHeaders['Authorization'] = `Bearer ${fresh}`;
+                continue;
+            }
+            if ((response.status === 429 || response.status >= 500) && attempt < maxRetries) {
+                console.warn(`[iMIS] HTTP ${response.status} from ${url} — backing off`);
+                await this.Sleep(this.RetryAfterMs(response) ?? this.BackoffDelay(attempt));
+                continue;
+            }
+            return this.BuildRESTResponse(response);
+        }
+        throw new Error(`iMIS request failed after ${maxRetries + 1} attempts: ${url}`);
+    }
+    // ─── TestConnection ──────────────────────────────────────────────
     /**
-     * Test the connection by authenticating and hitting the /Party list endpoint
-     * with a minimal page size. Confirms both auth + data-plane connectivity.
+     * Tests connectivity by minting a password-grant token and listing one Party record. A 2xx
+     * confirms the OAuth2 credentials + base URL are valid against the live API.
      */
     async TestConnection(companyIntegration, contextUser) {
         try {
-            const auth = await this.GetAuth(companyIntegration, contextUser, true);
-            const url = `${auth.BaseUrl}/Party?Limit=1`;
+            const auth = (await this.Authenticate(companyIntegration, contextUser));
             const headers = this.BuildHeaders(auth);
+            const url = `${auth.BaseUrl}/Party?Limit=1`;
             const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
-            if (response.Status >= 200 && response.Status < 300) {
-                return {
-                    Success: true,
-                    Message: `Connected to iMIS EMS at ${auth.BaseUrl}`,
-                    ServerVersion: this.ExtractServerVersion(response.Headers),
-                };
+            if (response.Status < 200 || response.Status >= 300) {
+                return { Success: false, Message: `iMIS returned HTTP ${response.Status} from ${url}` };
             }
-            return { Success: false, Message: `iMIS responded HTTP ${response.Status}` };
+            return {
+                Success: true,
+                Message: `Connected to iMIS EMS at ${auth.BaseUrl}`,
+                ServerVersion: this.ExtractServerVersion(response.Headers),
+            };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             return { Success: false, Message: `Connection failed: ${message}` };
         }
     }
+    // ─── Discovery (metadata-driven baseline + runtime mechanism) ────
     /**
-     * Discover objects by merging:
-     *   1. Static IntegrationObject metadata (from MJ: Integration Objects table)
-     *   2. Runtime-discovered customer Business Objects via GET /BOEntityDefinition
-     *      — marked with IsCustom=true when not already present in static metadata.
+     * Discovers objects: the Declared core baseline from the IntegrationEngineBase cache, ADDITIVELY
+     * extended at runtime via the auth-gated /EntityDefinition endpoint (the tenant's customer
+     * Business-Object catalog). The catalog is NEVER baked into code — DiscoverObjects expresses only
+     * the discovery MECHANISM. Failures degrade gracefully to the Declared baseline.
      */
     async DiscoverObjects(companyIntegration, contextUser) {
-        const staticObjects = await super.DiscoverObjects(companyIntegration, contextUser);
-        const staticNames = new Set(staticObjects.map(o => o.Name.toLowerCase()));
+        const declared = await super.DiscoverObjects(companyIntegration, contextUser);
+        const declaredNames = new Set(declared.map(o => o.Name.toLowerCase()));
         try {
-            const customObjects = await this.DiscoverBusinessObjects(companyIntegration, contextUser);
-            const newCustom = customObjects.filter(co => !staticNames.has(co.Name.toLowerCase()));
-            return [...staticObjects, ...newCustom];
+            const discovered = await this.DiscoverEntityDefinitions(companyIntegration, contextUser);
+            const additive = discovered.filter(d => !declaredNames.has(d.Name.toLowerCase()));
+            return [...declared, ...additive];
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.warn(`[iMIS] Business Object discovery failed, returning static objects only: ${message}`);
-            return staticObjects;
+            console.warn(`[iMIS] EntityDefinition discovery failed, returning declared objects only: ${message}`);
+            return declared;
         }
     }
     /**
-     * Discover fields by merging:
-     *   1. Static IntegrationObjectField metadata (from MJ: Integration Object Fields table)
-     *   2. Runtime-discovered fields via GET /{entity}/metadata
-     *      — any live field not in the static metadata is appended with IsCustom=true
-     *      (surfaced to callers via the IsForeignKey=false / IsReadOnly mix from the live API).
+     * Discovers fields: the Declared baseline from the cache, ADDITIVELY extended at runtime via the
+     * auth-gated /{entity}/metadata endpoint (the tenant's PropertyDefinitions). The field set is
+     * NEVER baked in code. Failures degrade gracefully to the Declared baseline.
      */
     async DiscoverFields(companyIntegration, objectName, contextUser) {
-        const staticFields = await super.DiscoverFields(companyIntegration, objectName, contextUser);
+        const declared = await super.DiscoverFields(companyIntegration, objectName, contextUser);
         try {
-            const liveFields = await this.DiscoverFieldsFromLiveAPI(companyIntegration, objectName, contextUser);
-            return this.MergeFieldSchemas(staticFields, liveFields);
+            const live = await this.DiscoverFieldsFromLiveAPI(companyIntegration, objectName, contextUser);
+            return this.MergeFieldSchemas(declared, live);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.warn(`[iMIS] Live field discovery failed for "${objectName}", returning static fields: ${message}`);
-            return staticFields;
+            console.warn(`[iMIS] Live field discovery failed for "${objectName}", returning declared fields: ${message}`);
+            return declared;
         }
     }
+    // ─── FetchChanges override (watermark wiring) ────────────────────
     /**
-     * Override FetchChanges to stash the current watermark so AppendDefaultQueryParams
-     * can inject the UpdatedOn filter on list requests.
+     * Sets the watermark context the URL builder needs, delegates the walk to the base (which handles
+     * pagination + nested template-var paths), then advances the watermark from the returned records
+     * on the FINAL batch only (partial-failure-safe — a mid-stream failure leaves the watermark unchanged).
      */
     async FetchChanges(ctx) {
-        this.currentWatermark = ctx.WatermarkValue;
+        this.currentWatermark = ctx.WatermarkValue ?? undefined;
         try {
             const result = await super.FetchChanges(ctx);
-            result.NewWatermarkValue = this.ComputeNewWatermark(result.Records, ctx.WatermarkValue);
+            const isFinal = !result.HasMore;
+            result.NewWatermarkValue = isFinal
+                ? this.ComputeNewWatermark(result.Records, ctx.WatermarkValue)
+                : undefined;
             return result;
         }
         finally {
-            this.currentWatermark = null;
+            this.currentWatermark = undefined;
         }
     }
-    // ── Write operations ────────────────────────────────────────────
-    async CreateRecord(ctx) {
-        const companyIntegration = ctx.CompanyIntegration;
-        const contextUser = ctx.ContextUser;
-        const auth = await this.GetAuth(companyIntegration, contextUser);
-        const url = `${auth.BaseUrl}/${this.NormalizeObjectPath(ctx.ObjectName)}`;
-        const headers = this.BuildHeaders(auth);
-        const response = await this.MakeHTTPRequest(auth, url, 'POST', headers, ctx.Attributes);
-        if (response.Status >= 200 && response.Status < 300) {
-            const body = response.Body;
-            return this.BuildCreatedResult(this.ExtractIdFromRecord(body), response.Status, ctx.ObjectName);
-        }
-        return this.BuildCRUDError(response, 'CreateRecord', ctx.ObjectName);
-    }
-    async UpdateRecord(ctx) {
-        const companyIntegration = ctx.CompanyIntegration;
-        const contextUser = ctx.ContextUser;
-        const auth = await this.GetAuth(companyIntegration, contextUser);
-        const objectPath = this.NormalizeObjectPath(ctx.ObjectName);
-        // iMIS PUT is a full replace — do a read-modify-write merge of Attributes
-        // into the current record so callers can supply partial updates.
-        const current = await this.FetchSingleRecord(auth, objectPath, ctx.ExternalID);
-        if (!current) {
-            return { Success: false, ErrorMessage: `Record ${ctx.ExternalID} not found`, StatusCode: 404 };
-        }
-        const merged = { ...current, ...ctx.Attributes };
-        const url = `${auth.BaseUrl}/${objectPath}/${encodeURIComponent(ctx.ExternalID)}`;
-        const headers = this.BuildHeaders(auth);
-        const response = await this.MakeHTTPRequest(auth, url, 'PUT', headers, merged);
-        if (response.Status >= 200 && response.Status < 300) {
-            return { Success: true, ExternalID: ctx.ExternalID, StatusCode: response.Status };
-        }
-        return this.BuildCRUDError(response, 'UpdateRecord', ctx.ObjectName);
-    }
-    async DeleteRecord(ctx) {
-        const companyIntegration = ctx.CompanyIntegration;
-        const contextUser = ctx.ContextUser;
-        const auth = await this.GetAuth(companyIntegration, contextUser);
-        const url = `${auth.BaseUrl}/${this.NormalizeObjectPath(ctx.ObjectName)}/${encodeURIComponent(ctx.ExternalID)}`;
-        const headers = this.BuildHeaders(auth);
-        const response = await this.MakeHTTPRequest(auth, url, 'DELETE', headers);
-        if (response.Status >= 200 && response.Status < 300) {
-            return { Success: true, ExternalID: ctx.ExternalID, StatusCode: response.Status };
-        }
-        return this.BuildCRUDError(response, 'DeleteRecord', ctx.ObjectName);
-    }
-    async GetRecord(ctx) {
-        const companyIntegration = ctx.CompanyIntegration;
-        const contextUser = ctx.ContextUser;
-        const auth = await this.GetAuth(companyIntegration, contextUser);
-        const record = await this.FetchSingleRecord(auth, this.NormalizeObjectPath(ctx.ObjectName), ctx.ExternalID);
-        if (!record)
-            return null;
-        return {
-            ExternalID: ctx.ExternalID,
-            ObjectType: ctx.ObjectName,
-            Fields: record,
-        };
-    }
     // ── Default configuration / field mappings ──────────────────────
     GetDefaultConfiguration() {
         return {
@@ -344,152 +446,27 @@ let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
     // ─────────────────────────────────────────────────────────────────
     //                         Private helpers
     // ─────────────────────────────────────────────────────────────────
-    // ── Auth helpers ────────────────────────────────────────────────
-    /**
-     * Returns a valid auth context, refreshing the access token as needed.
-     * Accepts either (companyIntegration, contextUser) for the first call
-     * or a pre-parsed config for silent refresh from MakeHTTPRequest.
-     */
-    async GetAuth(source, contextUser, forceRefresh = false) {
-        if (!forceRefresh && this.authState && this.IsTokenValid(this.authState)) {
-            return this.authState;
-        }
-        const config = this.IsConfig(source)
-            ? source
-            : await this.ParseConfig(source, contextUser);
-        this.authState = await this.AcquireToken(config);
-        return this.authState;
-    }
-    IsConfig(source) {
-        return source.BaseUrl !== undefined
-            && source.Username !== undefined;
-    }
-    IsTokenValid(auth) {
-        return auth.ExpiresAt.getTime() > Date.now() + TOKEN_REFRESH_BUFFER_MS;
-    }
-    async AcquireToken(config) {
-        const baseUrl = this.StripTrailingSlash(config.BaseUrl);
-        const tokenUrl = this.ResolveTokenEndpoint(baseUrl);
-        const body = this.BuildTokenRequestBody(config);
-        const response = await fetch(tokenUrl, {
-            method: 'POST',
-            headers: {
-                'Accept': 'application/json',
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body,
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`iMIS token request failed (${response.status}): ${text.slice(0, 300)}`);
-        }
-        const payload = await response.json();
-        const expiresAt = new Date(Date.now() + (payload.expires_in ?? 3600) * 1000);
-        if (payload.refresh_token) {
-            config.RefreshToken = payload.refresh_token;
-        }
-        return {
-            Token: payload.access_token,
-            ExpiresAt: expiresAt,
-            Config: config,
-            BaseUrl: baseUrl,
-        };
-    }
-    /**
-     * iMIS issues tokens at the scheduler path, not under /api/. Strip /api[/]
-     * from the BaseUrl when constructing the token endpoint.
-     */
-    ResolveTokenEndpoint(baseUrl) {
-        const trimmed = baseUrl.replace(/\/api\/?$/i, '');
-        // Vendor-canonical path is lowercase '/token/' per developer.imis.com docs.
-        // IIS is normally case-insensitive on URL paths so '/Token' usually works,
-        // but a few customer reverse-proxies enforce case strictness — match docs.
-        return `${trimmed}/token/`;
-    }
-    BuildTokenRequestBody(config) {
-        const params = new URLSearchParams();
-        if (config.ClientId && config.ClientSecret && config.RefreshToken) {
-            params.set('grant_type', 'refresh_token');
-            params.set('refresh_token', config.RefreshToken);
-            params.set('client_id', config.ClientId);
-            params.set('client_secret', config.ClientSecret);
-            return params.toString();
-        }
-        params.set('grant_type', 'password');
-        params.set('username', config.Username);
-        params.set('password', config.Password);
-        return params.toString();
-    }
-    // ── Configuration parsing ───────────────────────────────────────
-    async ParseConfig(companyIntegration, contextUser) {
-        if (companyIntegration.CredentialID) {
-            const config = await this.ParseConfigFromCredential(companyIntegration.CredentialID, contextUser);
-            if (config)
-                return config;
-        }
-        if (companyIntegration.Configuration) {
-            const parsed = JSON.parse(companyIntegration.Configuration);
-            return this.ExtractConfig(parsed);
-        }
-        throw new Error('iMIS connector requires either CredentialID or Configuration JSON');
-    }
-    async ParseConfigFromCredential(credentialID, contextUser, provider) {
-        const md = provider ?? new Metadata();
-        const credential = await md.GetEntityObject('MJ: Credentials', contextUser);
-        const loaded = await credential.Load(credentialID);
-        if (!loaded || !credential.Values)
-            return null;
-        const values = JSON.parse(credential.Values);
-        return this.ExtractConfig(values);
-    }
-    ExtractConfig(values) {
-        const get = (...keys) => {
-            for (const key of keys) {
-                const hit = Object.entries(values).find(([k]) => k.toLowerCase() === key.toLowerCase());
-                if (hit)
-                    return String(hit[1] ?? '');
-            }
-            return undefined;
-        };
-        const baseUrl = get('BaseUrl', 'baseUrl', 'base_url');
-        const username = get('Username', 'username', 'user');
-        const password = get('Password', 'password', 'pass');
-        if (!baseUrl)
-            throw new Error('iMIS configuration missing required field: BaseUrl');
-        if (!username)
-            throw new Error('iMIS configuration missing required field: Username');
-        if (!password)
-            throw new Error('iMIS configuration missing required field: Password');
-        return {
-            BaseUrl: this.StripTrailingSlash(baseUrl),
-            Username: username,
-            Password: password,
-            ClientId: get('ClientId', 'clientId', 'client_id'),
-            ClientSecret: get('ClientSecret', 'clientSecret', 'client_secret'),
-            RefreshToken: get('RefreshToken', 'refreshToken', 'refresh_token'),
-        };
-    }
-    // ── Runtime discovery (BOs + field metadata) ────────────────────
-    async DiscoverBusinessObjects(companyIntegration, contextUser) {
-        const auth = await this.GetAuth(companyIntegration, contextUser);
-        const url = `${auth.BaseUrl}/BOEntityDefinition?Limit=500`;
+    // ── Runtime discovery (Business Objects + field metadata) ───────
+    async DiscoverEntityDefinitions(companyIntegration, contextUser) {
+        const auth = (await this.Authenticate(companyIntegration, contextUser));
+        const url = `${auth.BaseUrl}/EntityDefinition?Limit=500`;
         const headers = this.BuildHeaders(auth);
         const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
         if (response.Status < 200 || response.Status >= 300)
             return [];
         const records = this.NormalizeResponse(response.Body, 'Items');
         return records
-            .filter(bo => !!bo.Name)
-            .map(bo => ({
-            Name: String(bo.Name),
-            Label: bo.DisplayName ?? String(bo.Name),
-            Description: bo.Description ?? `Customer-defined Business Object (runtime-discovered)`,
+            .filter(d => !!d.Name)
+            .map(d => ({
+            Name: String(d.Name),
+            Label: d.DisplayName ?? String(d.Name),
+            Description: d.Description ?? 'Tenant-defined Business Object (runtime-discovered)',
             SupportsIncrementalSync: true,
-            SupportsWrite: true,
+            SupportsWrite: false,
         }));
     }
     async DiscoverFieldsFromLiveAPI(companyIntegration, objectName, contextUser) {
-        const auth = await this.GetAuth(companyIntegration, contextUser);
+        const auth = (await this.Authenticate(companyIntegration, contextUser));
         const path = this.ResolveObjectPath(companyIntegration.IntegrationID, objectName);
         const url = `${auth.BaseUrl}${path}/metadata`;
         const headers = this.BuildHeaders(auth);
@@ -511,25 +488,25 @@ let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
             Description: prop.Description,
             DataType: genericType,
             IsRequired: !!prop.IsRequired,
+            // Provable-only: the source explicitly distinguishes PK; only set PK when stated.
+            IsPrimaryKey: prop.IsPrimaryKey === true ? true : undefined,
             IsUniqueKey: !!prop.IsPrimaryKey,
             IsReadOnly: !!prop.IsReadOnly,
+            MaxLength: prop.MaxLength ?? undefined,
         };
     }
     /**
-     * Merge live-discovered fields with static metadata. Live-only fields are
-     * treated as custom — surfaced with whatever properties the live API reports.
-     * Static fields override live fields on matching names (static metadata
-     * reflects the curated MJ schema).
+     * Merge live-discovered fields with the Declared baseline. Live-only fields are appended;
+     * Declared fields win on matching names (the curated MJ schema is authoritative for the baseline).
      */
-    MergeFieldSchemas(staticFields, liveFields) {
-        const staticNames = new Set(staticFields.map(f => f.Name.toLowerCase()));
-        const liveOnly = liveFields.filter(f => !staticNames.has(f.Name.toLowerCase()));
-        return [...staticFields, ...liveOnly];
+    MergeFieldSchemas(declared, live) {
+        const declaredNames = new Set(declared.map(f => f.Name.toLowerCase()));
+        const liveOnly = live.filter(f => !declaredNames.has(f.Name.toLowerCase()));
+        return [...declared, ...liveOnly];
     }
     /**
-     * Resolve an object name to its API path. Prefers the configured APIPath
-     * from IntegrationObject metadata; falls back to `/{ObjectName}` for
-     * runtime-discovered Business Objects.
+     * Resolve an object name to its API path. Prefers the configured APIPath from IntegrationObject
+     * metadata; falls back to `/{ObjectName}` for runtime-discovered Business Objects.
      */
     ResolveObjectPath(integrationID, objectName) {
         try {
@@ -539,34 +516,96 @@ let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
             }
         }
         catch {
-            // Not in static metadata — this is a runtime-discovered Business Object.
+            // Not in Declared metadata — a runtime-discovered Business Object.
         }
         return `/${objectName}`;
     }
-    /** Derive the URL path segment used by CRUD operations (no leading slash). */
-    NormalizeObjectPath(objectName) {
-        return objectName.startsWith('/') ? objectName.slice(1) : objectName;
+    // ── Config parsing ──────────────────────────────────────────────
+    /**
+     * Parses the connection config, preferring the attached MJ Credential over the raw Configuration
+     * JSON. Credential bytes are resolved at runtime — never at build.
+     */
+    async ParseConfig(companyIntegration, contextUser) {
+        if (companyIntegration.CredentialID) {
+            return this.ParseConfigFromCredential(companyIntegration.CredentialID, contextUser);
+        }
+        if (companyIntegration.Configuration) {
+            return this.ValidateConfig(JSON.parse(companyIntegration.Configuration));
+        }
+        throw new Error('iMIS connector requires either CredentialID or Configuration JSON');
     }
-    // ── Record / watermark helpers ──────────────────────────────────
-    async FetchSingleRecord(auth, objectPath, id) {
-        const url = `${auth.BaseUrl}/${objectPath}/${encodeURIComponent(id)}`;
-        const headers = this.BuildHeaders(auth);
-        const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
-        if (response.Status < 200 || response.Status >= 300)
-            return null;
-        if (response.Body == null || typeof response.Body !== 'object')
-            return null;
-        return response.Body;
-    }
-    ExtractIdFromRecord(body) {
-        const candidates = ['Id', 'ID', 'PartyId', 'UniformId', 'EventId', 'InvoiceId', 'PaymentId'];
-        for (const key of candidates) {
-            const value = body[key];
-            if (value !== undefined && value !== null)
-                return String(value);
+    /** Loads the config from the MJ: Credentials entity Values JSON. */
+    async ParseConfigFromCredential(credentialID, contextUser, provider) {
+        const md = provider ?? new Metadata();
+        const cred = await md.GetEntityObject('MJ: Credentials', contextUser);
+        const loaded = await cred.Load(credentialID);
+        if (!loaded || !cred.Values) {
+            throw new Error('iMIS credential could not be loaded or has no Values JSON');
         }
-        return '';
+        return this.ValidateConfig(JSON.parse(cred.Values));
+    }
+    /** Validates the parsed config + applies defaults. Field names are case-insensitive. */
+    ValidateConfig(raw) {
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('iMIS configuration is not a valid object');
+        }
+        const obj = raw;
+        const getStr = (...keys) => {
+            for (const key of keys) {
+                const lower = key.toLowerCase();
+                for (const [k, v] of Object.entries(obj)) {
+                    if (k.toLowerCase() === lower && typeof v === 'string' && v.length > 0)
+                        return v;
+                }
+            }
+            return undefined;
+        };
+        const getNum = (...keys) => {
+            for (const key of keys) {
+                const lower = key.toLowerCase();
+                for (const [k, v] of Object.entries(obj)) {
+                    if (k.toLowerCase() === lower && typeof v === 'number')
+                        return v;
+                }
+            }
+            return undefined;
+        };
+        const baseURL = getStr('baseurl', 'base_url');
+        if (!baseURL)
+            throw new Error('iMIS configuration missing required field: BaseURL');
+        const username = getStr('username', 'user');
+        const password = getStr('password', 'pass');
+        if (!username)
+            throw new Error('iMIS configuration missing required field: Username');
+        if (!password)
+            throw new Error('iMIS configuration missing required field: Password');
+        return {
+            BaseURL: baseURL,
+            Username: username,
+            Password: password,
+            TokenURL: getStr('tokenurl', 'token_url'),
+            ClientId: getStr('clientid', 'client_id'),
+            ClientSecret: getStr('clientsecret', 'client_secret'),
+            MaxRetries: getNum('maxretries') ?? DEFAULT_MAX_RETRIES,
+            RequestTimeoutMs: getNum('requesttimeoutms') ?? DEFAULT_REQUEST_TIMEOUT_MS,
+            MinRequestIntervalMs: getNum('minrequestintervalms') ?? DEFAULT_MIN_REQUEST_INTERVAL_MS,
+        };
+    }
+    /** Resolves the API base URL from the credential's BaseURL (never a hardcoded host). */
+    ResolveBaseUrl(config) {
+        return config.BaseURL.replace(/\/+$/, '');
+    }
+    /**
+     * Resolves the token endpoint: credential TokenURL override, else `{base}/token`. iMIS issues
+     * tokens at the host root (not under /api/), so a trailing /api segment is stripped.
+     */
+    ResolveTokenURL(config, baseUrl) {
+        if (config.TokenURL && config.TokenURL.length > 0)
+            return config.TokenURL;
+        const root = baseUrl.replace(/\/api$/i, '');
+        return `${root}${DEFAULT_TOKEN_PATH}`;
     }
+    // ── Watermark helper ────────────────────────────────────────────
     ComputeNewWatermark(records, current) {
         const candidateKeys = ['UpdatedOn', 'UpdateDate', 'ModifiedOn', 'LastUpdatedAt'];
         let latest;
@@ -584,99 +623,73 @@ let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
         return latest;
     }
     // ── HTTP helpers ────────────────────────────────────────────────
-    async ExecuteFetch(url, method, headers, body, timeoutMs) {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            return await fetch(url, {
-                method,
-                headers,
-                body: body !== undefined ? JSON.stringify(body) : undefined,
-                signal: controller.signal,
-            });
-        }
-        finally {
-            clearTimeout(timer);
-        }
+    /** Throttle to respect the configured minimum request interval. */
+    async ThrottleIfNeeded(minIntervalMs) {
+        const elapsed = Date.now() - this.lastRequestTime;
+        if (elapsed < minIntervalMs)
+            await this.Sleep(minIntervalMs - elapsed);
+    }
+    /** Parses a Retry-After header (seconds or http-date) into ms, if present. */
+    RetryAfterMs(response) {
+        const header = response.headers.get('retry-after');
+        if (!header)
+            return undefined;
+        const asSeconds = Number(header);
+        if (!isNaN(asSeconds))
+            return Math.max(0, asSeconds * 1_000);
+        const asDate = new Date(header).getTime();
+        if (!isNaN(asDate))
+            return Math.max(0, asDate - Date.now());
+        return undefined;
+    }
+    /** Exponential backoff delay for retry attempts (capped at 15s). */
+    BackoffDelay(attempt) {
+        return Math.min(1_000 * Math.pow(2, attempt), 15_000);
+    }
+    /** Checks whether an error is transient (network/timeout). */
+    IsTransientNetworkError(err) {
+        if (!(err instanceof Error))
+            return false;
+        const msg = err.message.toLowerCase();
+        return msg.includes('timeout') || msg.includes('abort') ||
+            msg.includes('econnreset') || msg.includes('econnrefused') ||
+            msg.includes('fetch failed');
     }
+    /** Builds the normalized RESTResponse from a fetch Response. */
     async BuildRESTResponse(response) {
         const headers = {};
         response.headers.forEach((v, k) => { headers[k.toLowerCase()] = v; });
-        const contentType = headers['content-type'] ?? '';
-        let bodyValue;
-        if (contentType.includes('application/json')) {
-            bodyValue = await this.ParseJsonSafely(response);
-        }
-        else {
-            bodyValue = await response.text();
-        }
-        return { Status: response.status, Body: bodyValue, Headers: headers };
-    }
-    async ParseJsonSafely(response) {
-        try {
-            return await response.json();
-        }
-        catch {
-            return null;
-        }
-    }
-    ShouldRetry(status) {
-        return status === 429 || status === 502 || status === 503 || status === 504;
-    }
-    ComputeRetryDelay(response, attempt) {
-        const retryAfter = response.headers.get('retry-after');
-        if (retryAfter) {
-            const seconds = Number.parseInt(retryAfter, 10);
-            if (!Number.isNaN(seconds) && seconds > 0)
-                return seconds * 1000;
+        const text = await response.text();
+        let body = null;
+        if (text.length > 0) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = text;
+            }
         }
-        return Math.min(Math.pow(2, attempt) * 1000, 15_000);
-    }
-    async Throttle(minIntervalMs) {
-        const elapsed = Date.now() - this.lastRequestTime;
-        if (elapsed < minIntervalMs)
-            await this.Sleep(minIntervalMs - elapsed);
-    }
-    Sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        return { Status: response.status, Body: body, Headers: headers };
     }
     ExtractServerVersion(headers) {
         return headers['x-imis-version'] ?? headers['server'] ?? 'iMIS REST API';
     }
+    /** True when a body is the iMIS PagedResult envelope (Items[] + Offset/Limit/HasNext). */
     IsPagedResult(body) {
         if (body == null || typeof body !== 'object' || Array.isArray(body))
             return false;
         const record = body;
         return Array.isArray(record['Items']) && ('Offset' in record || 'Limit' in record || 'HasNext' in record);
     }
-    StripTrailingSlash(url) {
-        return url.endsWith('/') ? url.slice(0, -1) : url;
-    }
-    BuildCRUDError(response, operation, objectName) {
-        const body = response.Body;
-        let detail;
-        if (typeof body === 'string') {
-            detail = body.slice(0, 500);
-        }
-        else if (body && typeof body === 'object') {
-            const asRecord = body;
-            const msg = asRecord['Message'] ?? asRecord['error_description'] ?? asRecord['error'];
-            detail = msg !== undefined ? String(msg) : JSON.stringify(body).slice(0, 500);
-        }
-        else {
-            detail = `HTTP ${response.Status}`;
-        }
-        return {
-            Success: false,
-            ErrorMessage: `iMIS ${operation} failed on ${objectName}: ${detail}`,
-            StatusCode: response.Status,
-        };
+    /** Promise-wrapped setTimeout. */
+    Sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
     }
 };
 IMISConnector = __decorate([
     RegisterClass(BaseIntegrationConnector, 'IMISConnector')
 ], IMISConnector);
 export { IMISConnector };
-/** Tree-shaking prevention — import and call from module entry point */
+/** Tree-shaking prevention — import and call from the package entry point. */
 export function LoadIMISConnector() { }
 //# sourceMappingURL=IMISConnector.js.map