@machinemetrics/mm-erp-sdk 0.1.9 → 0.2.0-beta.1

package/dist/mm-erp-sdk.js

@@ -0,0 +1,4978 @@
+import { C as CoreConfiguration, H as HashedCacheManager } from "./hashed-cache-manager-B15NN8hK.js";
+import { E, g, a } from "./hashed-cache-manager-B15NN8hK.js";
+import { l as logger } from "./logger-BWw0_z9q.js";
+import { g as getCachedMMToken, s as setCachedMMToken, a as setTimezoneOffsetInCache, b as setTimezoneNameInCache, c as getCachedTimezoneOffset, S as SQLiteCoordinator } from "./index-D8qO1NyK.js";
+import { f, d, e } from "./index-D8qO1NyK.js";
+import axios, { AxiosError } from "axios";
+import knex from "knex";
+import { c as config } from "./knexfile-Bng2Ru9c.js";
+import fs from "fs";
+import path from "path";
+import { c as createConnectorFromPath } from "./connector-factory-BPm2GVVF.js";
+import Bree from "bree";
+import Graceful from "@ladjs/graceful";
+import { fileURLToPath } from "url";
+import { StringCodec, connect } from "nats";
+import sql from "mssql";
+import { z } from "zod";
+var ERPObjType = /* @__PURE__ */ ((ERPObjType2) => {
+  ERPObjType2[ERPObjType2["RESOURCES"] = 0] = "RESOURCES";
+  ERPObjType2[ERPObjType2["PARTS"] = 1] = "PARTS";
+  ERPObjType2[ERPObjType2["PART_OPERATION"] = 2] = "PART_OPERATION";
+  ERPObjType2[ERPObjType2["WORK_ORDERS"] = 3] = "WORK_ORDERS";
+  ERPObjType2[ERPObjType2["WORK_ORDER_OPERATIONS"] = 4] = "WORK_ORDER_OPERATIONS";
+  ERPObjType2[ERPObjType2["PERSONS"] = 5] = "PERSONS";
+  ERPObjType2[ERPObjType2["REASONS"] = 6] = "REASONS";
+  ERPObjType2[ERPObjType2["LABOR_TICKETS"] = 7] = "LABOR_TICKETS";
+  return ERPObjType2;
+})(ERPObjType || {});
+const erpTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ERPObjType
+}, Symbol.toStringTag, { value: "Module" }));
+var Operator = /* @__PURE__ */ ((Operator2) => {
+  Operator2["eq"] = "eq";
+  Operator2["lt"] = "lt";
+  Operator2["lte"] = "lte";
+  Operator2["gt"] = "gt";
+  Operator2["gte"] = "gte";
+  return Operator2;
+})(Operator || {});
+const buildLogicalCondition = (conditions, operator) => {
+  return conditions.map(
+    (condition) => `${condition.field} ${condition.operator} '${condition.value}'`
+  ).join(` ${operator} `);
+};
+class MMReceiveLaborTicket {
+  constructor(data) {
+    Object.assign(this, data);
+  }
+  // Returns the closed date if it is a valid date, otherwise returns null
+  get workOrderOperationClosedDate() {
+    const closedDate = this.workOrderOperation?.closedDate;
+    return typeof closedDate === "string" && closedDate !== "" && !isNaN(Date.parse(closedDate)) ? closedDate : null;
+  }
+  set workOrderOperationClosedDate(value) {
+    if (this.workOrderOperation) {
+      this.workOrderOperation.closedDate = value;
+    }
+  }
+  // Returns 1 if the work order operation is closed (has a valid closed date), 0 otherwise
+  get workOrderOpIsClosed() {
+    return this.workOrderOperationClosedDate !== null ? 1 : 0;
+  }
+  /*Descriptions from machinemetrics.atlassian.net/wiki/spaces/DEVE/pages/842661901/MM+ERP+Schema+Descriptions*/
+  badParts;
+  // The number of parts produced that do not meet quality standards
+  clockIn;
+  // The timestamp when the work on this ticket started
+  clockOut;
+  // The timestamp when the work on this ticket ended
+  comment;
+  createdAt;
+  goodParts;
+  // The number of parts produced that meet quality standards
+  laborTicketId;
+  // The unique identifier for the labor ticket in the ERP
+  laborTicketRef;
+  // The unique identifier for the labor ticket in MM
+  lot;
+  // Refers to a material batch. If not available in the ERP, default to an empty string
+  personId;
+  // The person who did the work
+  reasons;
+  resourceId;
+  // The physical resource that did the work
+  resource;
+  // The resource name (available from export/updates endpoint)
+  sequenceNumber;
+  // Which sequence this operation is for in the order, associates back to a part_operation with the part_number from the work_order, and sequence_number from the op
+  split;
+  // Batch number if order split for staggered delivery. If not available in the ERP, default to an empty string
+  state;
+  // The current state of the labor ticket (e.g., "CLOSED/OPEN")
+  type;
+  // If the labor is production, setup, or indirect
+  syncedAt;
+  updatedAt;
+  workOrderId;
+  // The order this labor ticket corresponds to
+  workOrderOperation;
+  sub;
+  // Batch number for parts that had to be rerun. If not available in the ERP, default to an empty string
+  transactionDate;
+}
+class HTTPError extends Error {
+  constructor(message, status, code, data) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.data = data;
+    this.name = "HTTPError";
+  }
+}
+class HTTPClientFactory {
+  static getInstance(config2) {
+    return new AxiosClient(config2.baseUrl, config2.retryAttempts);
+  }
+}
+class AxiosClient {
+  client = null;
+  retryAttempts;
+  isDestroyed = false;
+  inFlightControllers = /* @__PURE__ */ new Set();
+  pendingTimeouts = /* @__PURE__ */ new Set();
+  pendingSleepResolvers = /* @__PURE__ */ new Set();
+  /**
+   * Note regarding baseURL, from https://github.com/axios/axios
+   *   `baseURL` will be prepended to `url` unless `url` is absolute and option `allowAbsoluteUrls` is set to true (the default).
+   *   It can be convenient to set `baseURL` for an instance of axios to pass relative URLs to methods of that instance.
+   */
+  constructor(baseUrl, retryAttempts) {
+    const timeout = parseInt(process.env.MM_API_TIMEOUT || "30000");
+    this.client = axios.create({
+      baseURL: baseUrl,
+      timeout,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.retryAttempts = retryAttempts;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => {
+      if (this.isDestroyed) {
+        resolve();
+        return;
+      }
+      const timeout = setTimeout(() => {
+        this.pendingTimeouts.delete(timeout);
+        this.pendingSleepResolvers.delete(resolve);
+        resolve();
+      }, ms);
+      this.pendingTimeouts.add(timeout);
+      this.pendingSleepResolvers.add(resolve);
+    });
+  }
+  async request(config2) {
+    if (this.isDestroyed || !this.client) {
+      throw new HTTPError("HTTP client has been destroyed", 500);
+    }
+    const controller = new AbortController();
+    this.inFlightControllers.add(controller);
+    const axiosConfig = {
+      method: config2.method,
+      url: config2.url,
+      headers: config2.headers,
+      data: config2.data,
+      params: config2.params,
+      signal: controller.signal
+    };
+    logger.info("HTTP request starting", {
+      url: config2.url,
+      method: config2.method,
+      baseURL: this.client.defaults.baseURL,
+      retryAttempts: this.retryAttempts
+    });
+    console.log("=== FULL URL DEBUG ===");
+    console.log("baseURL:", this.client.defaults.baseURL);
+    console.log("relative url:", config2.url);
+    console.log("full constructed URL:", (this.client.defaults.baseURL || "") + config2.url);
+    console.log("method:", config2.method);
+    let lastError;
+    try {
+      for (let attempt = 0; attempt <= this.retryAttempts; attempt++) {
+        try {
+          logger.info(`HTTP request attempt ${attempt + 1}/${this.retryAttempts + 1}`);
+          const response = await this.client.request(axiosConfig);
+          logger.info("HTTP request succeeded", { status: response.status });
+          return {
+            data: response.data,
+            status: response.status,
+            headers: response.headers
+          };
+        } catch (error) {
+          lastError = error;
+          const isAxiosErr = error instanceof AxiosError;
+          const code = isAxiosErr ? error.code : void 0;
+          const status = isAxiosErr ? error.response?.status : void 0;
+          const errorConstructor = error instanceof Error ? error.constructor.name : void 0;
+          const message = error instanceof Error ? error.message : String(error);
+          logger.info(`HTTP request attempt ${attempt + 1} failed`, {
+            errorType: typeof error,
+            errorConstructor,
+            isAxiosError: isAxiosErr,
+            message,
+            code,
+            status
+          });
+          if (error instanceof AxiosError && error.response?.status && error.response.status >= 400 && error.response.status < 500) {
+            logger.info("Not retrying due to 4xx client error");
+            break;
+          }
+          if (error instanceof AxiosError && error.code === "ERR_CANCELED") {
+            break;
+          }
+          if (attempt < this.retryAttempts) {
+            const waitTime = Math.pow(2, attempt) * 1e3;
+            logger.info(`Waiting ${waitTime}ms before retry`);
+            await this.sleep(waitTime);
+            if (this.isDestroyed) {
+              throw new HTTPError("HTTP client has been destroyed", 500);
+            }
+          }
+        }
+      }
+    } finally {
+      this.inFlightControllers.delete(controller);
+    }
+    logger.info("HTTP request failed after all retries, throwing error");
+    throw this.handleError(lastError, config2);
+  }
+  handleError(error, requestConfig) {
+    if (error instanceof AxiosError) {
+      const baseUrl = this.client?.defaults.baseURL || "";
+      const fullUrl = requestConfig ? `${baseUrl}${requestConfig.url}` : "Unknown URL";
+      const method = requestConfig?.method || "Unknown method";
+      const errorMessage = `${error.message} (${method} ${fullUrl})`;
+      return new HTTPError(
+        errorMessage,
+        error.response?.status || 500,
+        error.code,
+        error.response?.data
+      );
+    }
+    return new HTTPError(
+      error instanceof Error ? error.message : "Unknown error occurred",
+      500
+    );
+  }
+  async destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    for (const c of this.inFlightControllers) {
+      try {
+        c.abort();
+      } catch {
+      }
+    }
+    this.inFlightControllers.clear();
+    for (const t of this.pendingTimeouts) {
+      clearTimeout(t);
+    }
+    this.pendingTimeouts.clear();
+    for (const resolve of this.pendingSleepResolvers) {
+      try {
+        resolve();
+      } catch {
+      }
+    }
+    this.pendingSleepResolvers.clear();
+    this.client = null;
+  }
+}
+class MMTokenManager {
+  token;
+  tokenExpiration;
+  baseUrl;
+  api;
+  constructor() {
+    const cached = getCachedMMToken();
+    this.token = cached?.token || "";
+    this.tokenExpiration = cached?.expiration ? new Date(cached.expiration) : null;
+    const config2 = CoreConfiguration.inst();
+    console.log("=== MMTOKEN MANAGER DEBUG ===");
+    console.log("config.mmApiBaseUrl:", config2.mmApiBaseUrl);
+    console.log("config object keys:", Object.keys(config2));
+    this.baseUrl = config2.mmApiBaseUrl;
+    console.log("this.baseUrl set to:", this.baseUrl);
+    console.log("=== END MMTOKEN MANAGER DEBUG ===");
+    this.api = HTTPClientFactory.getInstance({
+      baseUrl: this.baseUrl,
+      retryAttempts: config2.mmApiRetryAttempts
+    });
+  }
+  /**
+   * Checks if the current token is expired or will expire within the next minute
+   * @returns boolean indicating if token needs refresh
+   */
+  isTokenExpired() {
+    if (!this.tokenExpiration) return true;
+    const bufferTimeMS = 6e4;
+    const isExpired = this.tokenExpiration.getTime() - bufferTimeMS <= Date.now();
+    if (isExpired) {
+      logger.info("isTokenExpired: the api token from MM has expired");
+    }
+    return isExpired;
+  }
+  /**
+   * Safely extracts expiration time from JWT token
+   * @param token JWT token string
+   * @returns Date object representing token expiration, or null if cannot be determined
+   */
+  getTokenExpiration(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) {
+        console.warn("Invalid JWT format: token does not have 3 parts");
+        return null;
+      }
+      const payload = Buffer.from(parts[1], "base64").toString("utf-8");
+      const decodedPayload = JSON.parse(payload);
+      if (typeof decodedPayload.exp !== "number") {
+        console.warn("JWT does not contain expiration time (exp claim)");
+        return null;
+      }
+      return new Date(decodedPayload.exp * 1e3);
+    } catch (error) {
+      console.warn("Error parsing JWT token:", error);
+      return null;
+    }
+  }
+  /**
+   * Gets a valid token, either from cache or by requesting a new one
+   * @returns Promise resolving to a valid token string
+   */
+  async getToken() {
+    if (this.token && !this.isTokenExpired()) {
+      return this.token;
+    }
+    const config2 = CoreConfiguration.inst();
+    const serviceToken = config2.mmApiAuthToken;
+    const tokenResponse = await this.api.request({
+      url: "/user-token",
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${serviceToken}`
+      }
+    });
+    this.token = tokenResponse.data;
+    this.tokenExpiration = this.getTokenExpiration(this.token);
+    setCachedMMToken({
+      token: this.token,
+      expiration: this.tokenExpiration?.getTime() || null
+    });
+    logger.info("getToken: the api token from MM has been refreshed");
+    return this.token;
+  }
+  /**
+   * Invalidates the current token, forcing a fresh fetch on next getToken() call
+   */
+  invalidateToken() {
+    this.token = "";
+    this.tokenExpiration = null;
+    setCachedMMToken({ token: "", expiration: null });
+  }
+}
+class GraphQLError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "GraphQLError";
+  }
+}
+class ErrorHandler {
+  /**
+   * Transforms any error into a standardized HTTPError or GraphQLError and throws it.
+   * Never returns - always throws an error.
+   *
+   * @throws {HTTPError|GraphQLError} Standardized error with appropriate details
+   */
+  static handle(error) {
+    if (error instanceof HTTPError) {
+      if (error.data && typeof error.data === "object" && "errors" in error.data) {
+        const graphqlError = new GraphQLError(
+          "GraphQL Error",
+          error.data.errors
+        );
+        logger.error("Error>>GraphQL", {
+          message: graphqlError.message,
+          errors: graphqlError.errors
+        });
+        throw graphqlError;
+      }
+      logger.error("Error>>HTTP", {
+        status: error.status,
+        message: error.message,
+        code: error.code,
+        data: error.data
+      });
+      throw error;
+    }
+    if (error instanceof AxiosError) {
+      if (error.response?.data?.errors) {
+        const graphqlError = new GraphQLError(
+          "GraphQL Error",
+          error.response.data.errors
+        );
+        logger.error("Error>>GraphQL", {
+          message: graphqlError.message,
+          errors: graphqlError.errors
+        });
+        throw graphqlError;
+      }
+      const httpError2 = new HTTPError(
+        error.message,
+        error.response?.status || 500,
+        error.code,
+        error.response?.data
+      );
+      logger.error("Error>>HTTP", {
+        status: httpError2.status,
+        message: httpError2.message,
+        code: httpError2.code,
+        data: httpError2.data
+      });
+      throw httpError2;
+    }
+    const httpError = new HTTPError(
+      error instanceof Error ? error.message : "An unknown error occurred",
+      500
+    );
+    logger.error("Error>>Unknown", {
+      message: httpError.message,
+      status: httpError.status
+    });
+    throw httpError;
+  }
+}
+const MAPPING = "MAPPING";
+const CHECKPOINTS = "CHECKPOINTS";
+const MACHINE_GROUPS = "MACHINE_GROUPS";
+const GRAPHQL = "GRAPHQL";
+var UrlBase = /* @__PURE__ */ ((UrlBase2) => {
+  UrlBase2["ErpApiSvcBase"] = "ErpApiSvcBase";
+  UrlBase2["ApiBase"] = "ApiBase";
+  return UrlBase2;
+})(UrlBase || {});
+class MMApiClient {
+  tokenMgr;
+  api;
+  baseUrls;
+  resourceURLs = {
+    [ERPObjType.RESOURCES]: "/erp/v1/resources",
+    [ERPObjType.PARTS]: "/erp/v1/parts",
+    [ERPObjType.PART_OPERATION]: "/erp/v1/part-operations",
+    [ERPObjType.WORK_ORDERS]: "/erp/v1/production-orders",
+    [ERPObjType.WORK_ORDER_OPERATIONS]: "/erp/v1/production-order-operations",
+    [ERPObjType.PERSONS]: "/erp/v1/persons",
+    [ERPObjType.REASONS]: "/erp/v1/reasons",
+    [ERPObjType.LABOR_TICKETS]: "/erp/v1/labor-tickets",
+    [MAPPING]: "/erp/v1/mapping",
+    [CHECKPOINTS]: "/erp/v1/checkpoints",
+    [MACHINE_GROUPS]: "/machine-groups",
+    [GRAPHQL]: "/proxy/graphql"
+  };
+  constructor() {
+    this.tokenMgr = new MMTokenManager();
+    this.baseUrls = {
+      [
+        "ErpApiSvcBase"
+        /* ErpApiSvcBase */
+      ]: CoreConfiguration.inst().mmERPSvcApiBaseUrl,
+      [
+        "ApiBase"
+        /* ApiBase */
+      ]: CoreConfiguration.inst().mmApiBaseUrl
+    };
+    this.api = HTTPClientFactory.getInstance({
+      baseUrl: "",
+      retryAttempts: CoreConfiguration.inst().mmApiRetryAttempts
+    });
+  }
+  //#region Private Methods
+  async executeWithAuthRetry(operation, options = {}) {
+    let token = options.token || await this.tokenMgr.getToken();
+    try {
+      return await operation(token);
+    } catch (error) {
+      const hasStatus = (err) => {
+        return typeof err === "object" && err !== null && "status" in err;
+      };
+      const isAuthError = hasStatus(error) && (error.status === 401 || error.status === 403) || hasStatus(error) && error.status === 500 && typeof error.data?.error === "string" && error.data.error.includes("JWT");
+      if (isAuthError && !options.token) {
+        logger.info("Retrying request with fresh token due to auth error");
+        this.tokenMgr.invalidateToken();
+        token = await this.tokenMgr.getToken();
+        return await operation(token);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Fetch data from the MM API, with an auth retry mechanism
+   * Auth Retry Level (executeWithAuthRetry)
+   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
+   *  - These trigger a token refresh and one retry attempt
+   *  - If the retry still fails, the error is re-thrown
+   *
+   * HTTP Status Codes behavior:
+   *  - 2xx - Success, returns normally
+   *  - 4xx - Client errors, throws immediately
+   *  - 5xx - Server errors, retries then throws
+   *
+   * Flags:
+   */
+  async getData(path2, queryParams = {}, options = {}) {
+    try {
+      return await this.executeWithAuthRetry(async (token) => {
+        const baseUrl = options.baseUrl || "ErpApiSvcBase";
+        const params = new URLSearchParams({
+          ...queryParams,
+          ...baseUrl === "ErpApiSvcBase" ? { raw: "true" } : {}
+        });
+        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
+        const fullUrl = this.baseUrls[baseUrl] + url;
+        const result = await this.api.request({
+          url: fullUrl,
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            ...options.headers
+          }
+        });
+        return {
+          ...result.data,
+          httpStatus: result.status
+        };
+      }, options);
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * Send data to the MM API, with an auth retry mechanism
+   * Auth Retry Level (executeWithAuthRetry)
+   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
+   *  - These trigger a token refresh and one retry attempt
+   *  - If the retry still fails, the error is re-thrown
+   *
+   * HTTP Status Codes behavior:
+   *  - 2xx - Success, returns normally
+   *  - 4xx - Client errors, throws immediately
+   *  - 5xx - Server errors, retries then throws
+   *
+   * Flags:
+   *  - 'raw' = true and 'dedupe' = true will be set for MM's ERP API url
+   */
+  async postData(path2, data = {}, queryParams = {}, options = {}) {
+    try {
+      return await this.executeWithAuthRetry(async (token) => {
+        const baseUrl = options.baseUrl || "ErpApiSvcBase";
+        const params = new URLSearchParams({
+          ...queryParams,
+          ...baseUrl === "ErpApiSvcBase" ? { dedupe: "true", raw: "true" } : {}
+        });
+        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
+        const fullUrl = this.baseUrls[baseUrl] + url;
+        const request = {
+          url: fullUrl,
+          method: "POST",
+          data: JSON.stringify(data),
+          headers: {
+            Authorization: `Bearer ${token}`,
+            ...options.headers
+          }
+        };
+        const result = await this.api.request(request);
+        return {
+          ...result.data,
+          httpStatus: result.status
+        };
+      }, options);
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * Delete data from the MM API, with an auth retry mechanism
+   * Auth Retry Level (executeWithAuthRetry)
+   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
+   *  - These trigger a token refresh and one retry attempt
+   *  - If the retry still fails, the error is re-thrown
+   *
+   * HTTP Status Codes behavior:
+   *  - 2xx - Success, returns normally
+   *  - 4xx - Client errors, throws immediately
+   *  - 5xx - Server errors, retries then throws
+   *
+   */
+  async deleteData(path2, data = {}, options = {}) {
+    try {
+      return await this.executeWithAuthRetry(async (token) => {
+        const baseUrl = options.baseUrl || "ErpApiSvcBase";
+        const params = new URLSearchParams({
+          ...baseUrl === "ErpApiSvcBase" ? { raw: "true" } : {}
+        });
+        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
+        const fullUrl = this.baseUrls[baseUrl] + url;
+        const result = await this.api.request({
+          url: fullUrl,
+          method: "DELETE",
+          data,
+          headers: {
+            Authorization: `Bearer ${token}`,
+            ...options.headers
+          }
+        });
+        return {
+          ...result.data,
+          httpStatus: result.status
+        };
+      }, options);
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * Patch data to the MM API, with an auth retry mechanism
+   * Auth Retry Level (executeWithAuthRetry)
+   *  - 401 (Unauthorized) and 403 (Forbidden) get special treatment
+   *  - These trigger a token refresh and one retry attempt
+   *  - If the retry still fails, the error is re-thrown
+   *
+   * HTTP Status Codes behavior:
+   *  - 2xx - Success, returns normally
+   *  - 4xx - Client errors, throws immediately
+   *  - 5xx - Server errors, retries then throws
+   *
+   */
+  async patchData(path2, data = {}, options = {}) {
+    try {
+      return await this.executeWithAuthRetry(async (token) => {
+        const baseUrl = options.baseUrl || "ErpApiSvcBase";
+        const params = new URLSearchParams({
+          ...baseUrl === "ErpApiSvcBase" ? { raw: "true" } : {}
+        });
+        const url = params.size > 0 ? `${path2}?${params.toString()}` : path2;
+        const fullUrl = this.baseUrls[baseUrl] + url;
+        const request = {
+          url: fullUrl,
+          method: "PATCH",
+          data,
+          headers: {
+            Authorization: `Bearer ${token}`,
+            ...options.headers
+          }
+        };
+        const result = await this.api.request(request);
+        return {
+          ...result.data,
+          httpStatus: result.status
+        };
+      }, options);
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  async graphqlRequest(operationName, query) {
+    try {
+      return await this.postData(
+        this.resourceURLs[GRAPHQL],
+        { operationName, query },
+        {},
+        {
+          baseUrl: "ApiBase",
+          token: CoreConfiguration.inst().mmApiAuthToken,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * Fetch a checkpoint for a specific system, table, and checkpoint type
+   * @param checkpoint The checkpoint to fetch
+   * @returns Promise with the checkpoint data
+   */
+  async fetchCheckpoint(checkpoint) {
+    const { system, table, checkpointType } = checkpoint;
+    return this.getData(this.resourceURLs[CHECKPOINTS], {
+      system,
+      table,
+      checkpointType
+    });
+  }
+  //#endregion private methods
+  //#region Public Methods
+  /**
+   * Send resources to the MM API
+   * @param resources Array of resources to send
+   * @returns Promise with the API response
+   */
+  async sendResourcesToMM(resources) {
+    return await this.postData(this.resourceURLs[ERPObjType.RESOURCES], {
+      data: resources.map((resource) => resource.toRESTApiObject())
+    });
+  }
+  /**
+   * Send parts to the MM API
+   * @param parts Array of parts to send
+   * @returns Promise with the API response
+   */
+  async sendPartsToMM(parts) {
+    return await this.postData(this.resourceURLs[ERPObjType.PARTS], {
+      data: parts.map((part) => part.toRESTApiObject())
+    });
+  }
+  /**
+   * Send part operations to the MM API
+   * @param operations Array of part operations to send
+   * @returns Promise with the API response
+   */
+  async sendPartOperationsToMM(operations) {
+    return await this.postData(this.resourceURLs[ERPObjType.PART_OPERATION], {
+      data: operations.map((operation) => operation.toRESTApiObject())
+    });
+  }
+  /**
+   * Send work orders to the MM API
+   * @param workOrders Array of work orders to send
+   * @returns Promise with the API response
+   */
+  async sendWorkOrdersToMM(workOrders) {
+    return await this.postData(this.resourceURLs[ERPObjType.WORK_ORDERS], {
+      data: workOrders.map((workOrder) => workOrder.toRESTApiObject())
+    });
+  }
+  /**
+   * Send work order operations to the MM API
+   * @param workOrderOperations Array of work order operations to send
+   * @returns Promise with the API response
+   */
+  async sendWorkOrderOperationsToMM(workOrderOperations) {
+    return await this.postData(
+      this.resourceURLs[ERPObjType.WORK_ORDER_OPERATIONS],
+      {
+        data: workOrderOperations.map(
+          (operation) => operation.toRESTApiObject()
+        )
+      }
+    );
+  }
+  /**
+   * Send persons to the MM API
+   * @param persons Array of persons to send
+   * @returns Promise with the API response
+   */
+  async sendPersonsToMM(persons) {
+    return await this.postData(this.resourceURLs[ERPObjType.PERSONS], {
+      data: persons.map((person) => person.toRESTApiObject())
+    });
+  }
+  /**
+   * Send reasons to the MM API
+   * @param reasons Array of reasons to send
+   * @returns Promise with the API response
+   */
+  async sendReasonsToMM(reasons) {
+    return await this.postData(this.resourceURLs[ERPObjType.REASONS], {
+      data: reasons.map((reason) => reason.toRESTApiObject())
+    });
+  }
+  /**
+   * Send labor tickets to the MM API
+   * @param laborTickets Array of labor tickets to send
+   * @returns Promise with the API response
+   */
+  async sendLaborTicketsToMM(laborTickets) {
+    return await this.postData(this.resourceURLs[ERPObjType.LABOR_TICKETS], {
+      data: laborTickets.map((ticket) => ticket.toRESTApiObject())
+    });
+  }
+  /**
+   * Delete labor tickets from the MM API
+   * @param laborTickets Array of labor ticket records to delete
+   * @returns Promise with the API response
+   */
+  async deleteLaborTickets(laborTickets) {
+    logger.debug("deleteLaborTickets:", { laborTickets });
+    return await this.deleteData(this.resourceURLs[ERPObjType.LABOR_TICKETS], {
+      laborTickets
+    });
+  }
+  /**
+   * Fetch transformed labor tickets from the MM API
+   * @returns Promise with the transformed labor tickets
+   */
+  async fetchTransformedLaborTickets() {
+    return await this.getData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/export`
+    );
+  }
+  /**
+   * Fetch labor ticket updates from the MM API
+   * @param query Query parameters for filtering updates
+   * @returns Promise with an array of labor ticket updates
+   */
+  async fetchLaborTicketUpdates(query) {
+    const updates = await this.getData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/export/updates`,
+      query
+    );
+    return updates.data.map((ticket) => new MMReceiveLaborTicket(ticket));
+  }
+  /**
+   * Fetch a single labor ticket by reference from the MM API
+   * @param laborTicketRef The labor ticket reference to fetch
+   * @returns Promise with the labor ticket data
+   */
+  async fetchLaborTicketByRef(laborTicketRef) {
+    const response = await this.getData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/${laborTicketRef}`
+    );
+    return new MMReceiveLaborTicket(response.data);
+  }
+  /**
+   * Fetch a checkpoint for a specific system, table, and checkpoint type
+   * @param checkpoint The checkpoint to fetch
+   * @returns Promise with the checkpoint data
+   */
+  async getCheckpoint(checkpoint) {
+    return await this.fetchCheckpoint(checkpoint);
+  }
+  /**
+   * Save a checkpoint to the MM API
+   * @param checkpoint The checkpoint to save
+   * @returns Promise with the API response
+   */
+  async saveCheckpoint(checkpoint) {
+    return await this.postData(this.resourceURLs[CHECKPOINTS], checkpoint);
+  }
+  /**
+   * Initialize a checkpoint for a specific system, table, and checkpoint type
+   * @param checkpoint The checkpoint to initialize
+   * @returns Promise with the checkpoint data
+   */
+  async initializeCheckpoint(checkpoint) {
+    const currentCheckpoint = await this.fetchCheckpoint(checkpoint);
+    logger.info("currentCheckpoint:", { currentCheckpoint });
+    logger.info("currentCheckpoint keys:", {
+      keys: Object.keys(currentCheckpoint || {})
+    });
+    const checkpointResponse = currentCheckpoint;
+    const hasCheckpointData = checkpointResponse && checkpointResponse.timestamp;
+    if (!hasCheckpointData) {
+      logger.info("No checkpoint data found, initializing checkpoint");
+      const saveCheckpoint = await this.saveCheckpoint(checkpoint);
+      logger.info("saveCheckpoint:", { saveCheckpoint });
+    } else {
+      logger.info("Existing checkpoint found:", {
+        timestamp: checkpointResponse.timestamp
+      });
+    }
+  }
+  /**
+   * Send data to MM API based on the object type
+   * @param type The type of ERP object to send
+   * @param objects Array of objects to send
+   * @returns Promise with the API response including affected rows count
+   */
+  async sendDataToMMByType(type, objects) {
+    switch (type) {
+      case ERPObjType.PERSONS:
+        return await this.sendPersonsToMM(
+          objects
+        );
+      case ERPObjType.RESOURCES:
+        return await this.sendResourcesToMM(
+          objects
+        );
+      case ERPObjType.PARTS:
+        return await this.sendPartsToMM(objects);
+      case ERPObjType.PART_OPERATION:
+        return await this.sendPartOperationsToMM(
+          objects
+        );
+      case ERPObjType.WORK_ORDERS:
+        return await this.sendWorkOrdersToMM(
+          objects
+        );
+      case ERPObjType.WORK_ORDER_OPERATIONS:
+        return await this.sendWorkOrderOperationsToMM(
+          objects
+        );
+      case ERPObjType.REASONS:
+        return await this.sendReasonsToMM(
+          objects
+        );
+      case ERPObjType.LABOR_TICKETS:
+        return await this.sendLaborTicketsToMM(
+          objects
+        );
+      default:
+        throw new Error(`Unsupported type: ${ERPObjType[type]}`);
+    }
+  }
+  /**
+   * Update the labor ticket ERP ID by laborTicketRef
+   * @param laborTicketRef The MM API labor ticket unique ID
+   * @param erpObjectId The ERP labor ticket ID to update
+   * @returns The updated labor ticket
+   */
+  async updateLaborTicketIdByRef(laborTicketRef, laborTicketId) {
+    return await this.patchData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/${laborTicketRef}`,
+      { laborTicketId }
+    );
+  }
+  /**
+   * Add failed labor ticket refs to the MM API
+   * @param failedTicketRefs The failed labor ticket references
+   * @returns The response from the MM API
+   */
+  async addFailedLaborTicketRefs(system, failedTicketRefs) {
+    return await this.postData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/failed`,
+      { failedTicketRefs },
+      { system }
+    );
+  }
+  async fetchFailedLaborTickets(system) {
+    const failedTickets = await this.getData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/failed`,
+      { system }
+    );
+    return failedTickets.erpLaborTickets.map(
+      (ticket) => new MMReceiveLaborTicket(ticket)
+    );
+  }
+  /**
+   * Send connector logs to the MM API
+   * @param logEntry Single log entry to send
+   * @returns Promise with the API response
+   */
+  async sendConnectorLog(logEntry) {
+    return await this.postData(
+      "/connector/logs",
+      logEntry,
+      {},
+      {
+        baseUrl: "ApiBase"
+        /* ApiBase */
+      }
+    );
+  }
+  /**
+   * Send bulk connector logs to the MM API
+   * @param logs Array of log entries to send
+   * @returns Promise with the API response
+   */
+  async sendBulkConnectorLogs(logs) {
+    return await this.postData(
+      "/connector/logs",
+      { logs },
+      {},
+      {
+        baseUrl: "ApiBase"
+        /* ApiBase */
+      }
+    );
+  }
+  async deleteFailedLaborTicketIds(system, laborTicketRefs) {
+    return await this.postData(
+      `${this.resourceURLs[ERPObjType.LABOR_TICKETS]}/failed/remove`,
+      { laborTicketRefs },
+      { system }
+    );
+  }
+  /**
+   * Fetch machine groups from the MM API
+   * @returns Promise with the machine groups data
+   */
+  async fetchMachineGroups() {
+    return await this.getData(
+      this.resourceURLs[MACHINE_GROUPS],
+      {},
+      {
+        baseUrl: "ApiBase"
+        /* ApiBase */
+      }
+    );
+  }
+  /**
+   * Fetch resources using GraphQL
+   * @returns Promise with the resources data
+   */
+  async fetchResourcesFromGraphQL() {
+    return await this.graphqlRequest(
+      "getErpResources",
+      "query getErpResources { machineResource: erpResources { machineRef machineGroupId resourceId }}"
+    );
+  }
+  /**
+   * Cleanup all HTTP connections and resources
+   * Call this when the service is no longer needed
+   */
+  async destroy() {
+    await this.api.destroy();
+  }
+  //#endregion public methods
+}
+class MMSendPerson {
+  constructor(personId, firstName, lastName, isActive) {
+    this.personId = personId;
+    this.firstName = firstName;
+    this.lastName = lastName;
+    this.isActive = isActive;
+  }
+  toRESTApiObject() {
+    return {
+      personId: this.personId,
+      firstName: this.firstName,
+      lastName: this.lastName,
+      isActive: this.isActive ? "1" : "0"
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendPerson(
+      data.personId || "",
+      data.firstName || "",
+      data.lastName || "",
+      data.isActive === "1"
+    );
+  }
+}
+class MMSendResource {
+  constructor(resourceId, name, isResourceGroup, description, type, productionBurdenRateHourly, setupBurdenRateHourly) {
+    this.resourceId = resourceId;
+    this.name = name;
+    this.isResourceGroup = isResourceGroup;
+    this.description = description;
+    this.type = type;
+    this.productionBurdenRateHourly = productionBurdenRateHourly;
+    this.setupBurdenRateHourly = setupBurdenRateHourly;
+  }
+  toRESTApiObject() {
+    return {
+      resourceId: this.resourceId,
+      name: this.name,
+      isResourceGroup: this.isResourceGroup ? "1" : "0",
+      description: this.description,
+      type: this.type,
+      productionBurdenRateHourly: this.productionBurdenRateHourly.toString(),
+      setupBurdenRateHourly: this.setupBurdenRateHourly.toString()
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendResource(
+      data.resourceId || "",
+      data.name || "",
+      data.isResourceGroup === "1",
+      data.description || "",
+      data.type || "",
+      parseFloat(data.productionBurdenRateHourly || "0"),
+      parseFloat(data.setupBurdenRateHourly || "0")
+    );
+  }
+}
+class MMSendPart {
+  constructor(partNumber, partRevision, method) {
+    this.partNumber = partNumber;
+    this.partRevision = partRevision;
+    this.method = method;
+  }
+  toRESTApiObject() {
+    return {
+      partNumber: this.partNumber,
+      partRevision: this.partRevision,
+      method: this.method
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendPart(
+      data.partNumber || "",
+      data.partRevision || "",
+      data.method || ""
+    );
+  }
+}
+class MMSendPartOperation {
+  constructor(partNumber, partRevision, method, sequenceNumber, resourceId, cycleTimeMs, setupTimeMs, description, quantityPerPart) {
+    this.partNumber = partNumber;
+    this.partRevision = partRevision;
+    this.method = method;
+    this.sequenceNumber = sequenceNumber;
+    this.resourceId = resourceId;
+    this.cycleTimeMs = cycleTimeMs;
+    this.setupTimeMs = setupTimeMs;
+    this.description = description;
+    this.quantityPerPart = quantityPerPart;
+  }
+  toRESTApiObject() {
+    return {
+      partNumber: this.partNumber,
+      partRevision: this.partRevision,
+      method: this.method,
+      sequenceNumber: this.sequenceNumber,
+      resourceId: this.resourceId,
+      cycleTimeMs: this.cycleTimeMs.toString(),
+      setupTimeMs: this.setupTimeMs.toString(),
+      description: this.description,
+      quantityPerPart: this.quantityPerPart.toString()
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendPartOperation(
+      data.partNumber || "",
+      data.partRevision || "",
+      data.method || "",
+      data.sequenceNumber || "",
+      data.resourceId || "",
+      parseInt(data.cycleTimeMs || "0"),
+      parseInt(data.setupTimeMs || "0"),
+      data.description || "",
+      parseFloat(data.quantityPerPart || "1")
+    );
+  }
+}
+class MMSendWorkOrder {
+  constructor(workOrderId, lot, split, sub, status, dueDate, description, scheduledStartDate, scheduledEndDate, closedDate, quantityRequired, partNumber, partRevision, method) {
+    this.workOrderId = workOrderId;
+    this.lot = lot;
+    this.split = split;
+    this.sub = sub;
+    this.status = status;
+    this.dueDate = dueDate;
+    this.description = description;
+    this.scheduledStartDate = scheduledStartDate;
+    this.scheduledEndDate = scheduledEndDate;
+    this.closedDate = closedDate;
+    this.quantityRequired = quantityRequired;
+    this.partNumber = partNumber;
+    this.partRevision = partRevision;
+    this.method = method;
+  }
+  toRESTApiObject() {
+    return {
+      workOrderId: this.workOrderId,
+      lot: this.lot,
+      split: this.split,
+      sub: this.sub,
+      status: this.status,
+      dueDate: this.dueDate,
+      description: this.description,
+      scheduledStartDate: this.scheduledStartDate,
+      scheduledEndDate: this.scheduledEndDate,
+      closedDate: this.closedDate,
+      quantityRequired: this.quantityRequired.toString(),
+      partNumber: this.partNumber,
+      partRevision: this.partRevision,
+      method: this.method
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendWorkOrder(
+      data.workOrderId || "",
+      data.lot || "",
+      data.split || "",
+      data.sub || "",
+      data.status || "",
+      data.dueDate ?? null,
+      data.description || "",
+      data.scheduledStartDate ?? null,
+      data.scheduledEndDate ?? null,
+      data.closedDate ?? null,
+      parseFloat(data.quantityRequired || "0"),
+      data.partNumber || "",
+      data.partRevision || "",
+      data.method || ""
+    );
+  }
+}
+class MMSendWorkOrderOperation {
+  constructor(workOrderId, lot, split, sub, sequenceNumber, resourceId, startQuantity, finishQuantity, expectedRejectRate, scheduledStartDate, scheduledFinishDate, closedDate, cycleTimeMs, setupTimeMs, productionburdenRateHourly, setupburdenRatehourly, operationType, quantityPerPart, status) {
+    this.workOrderId = workOrderId;
+    this.lot = lot;
+    this.split = split;
+    this.sub = sub;
+    this.sequenceNumber = sequenceNumber;
+    this.resourceId = resourceId;
+    this.startQuantity = startQuantity;
+    this.finishQuantity = finishQuantity;
+    this.expectedRejectRate = expectedRejectRate;
+    this.scheduledStartDate = scheduledStartDate;
+    this.scheduledFinishDate = scheduledFinishDate;
+    this.closedDate = closedDate;
+    this.cycleTimeMs = cycleTimeMs;
+    this.setupTimeMs = setupTimeMs;
+    this.productionburdenRateHourly = productionburdenRateHourly;
+    this.setupburdenRatehourly = setupburdenRatehourly;
+    this.operationType = operationType;
+    this.quantityPerPart = quantityPerPart;
+    this.status = status;
+  }
+  toRESTApiObject() {
+    return {
+      workOrderId: this.workOrderId,
+      lot: this.lot,
+      split: this.split,
+      sub: this.sub,
+      sequenceNumber: this.sequenceNumber,
+      resourceId: this.resourceId,
+      startQuantity: this.startQuantity.toString(),
+      finishQuantity: this.finishQuantity.toString(),
+      expectedRejectRate: this.expectedRejectRate.toString(),
+      scheduledStartDate: this.scheduledStartDate,
+      scheduledFinishDate: this.scheduledFinishDate,
+      closedDate: this.closedDate,
+      cycleTimeMs: this.cycleTimeMs.toString(),
+      setupTimeMs: this.setupTimeMs.toString(),
+      productionburdenRateHourly: this.productionburdenRateHourly.toString(),
+      setupburdenRatehourly: this.setupburdenRatehourly.toString(),
+      operationType: this.operationType,
+      quantityPerPart: this.quantityPerPart.toString(),
+      status: this.status
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendWorkOrderOperation(
+      data.workOrderId || "",
+      data.lot || "",
+      data.split || "",
+      data.sub || "",
+      data.sequenceNumber || "",
+      data.resourceId || "",
+      parseFloat(data.startQuantity || "0"),
+      parseFloat(data.finishQuantity || "0"),
+      parseFloat(data.expectedRejectRate || "0"),
+      data.scheduledStartDate ?? null,
+      data.scheduledFinishDate ?? null,
+      data.closedDate ?? null,
+      parseInt(data.cycleTimeMs || "0"),
+      parseInt(data.setupTimeMs || "0"),
+      parseFloat(data.productionburdenRateHourly || "0"),
+      parseFloat(data.setupburdenRatehourly || "0"),
+      data.operationType || "",
+      parseFloat(data.quantityPerPart || "1"),
+      data.status || ""
+    );
+  }
+}
+class MMSendReason {
+  constructor(reasonId, category, code, description, entityType) {
+    this.reasonId = reasonId;
+    this.category = category;
+    this.code = code;
+    this.description = description;
+    this.entityType = entityType;
+  }
+  toRESTApiObject() {
+    return {
+      reasonId: this.reasonId,
+      category: this.category,
+      code: this.code,
+      description: this.description,
+      entityType: this.entityType
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendReason(
+      data.reasonId || "",
+      data.category || "",
+      data.code || "",
+      data.description || "",
+      data.entityType || ""
+    );
+  }
+}
+class MMSendLaborTicket {
+  constructor(workOrderId, lot, split, sub, sequenceNumber, resourceId, personId, laborTicketId, transactionDate, clockIn, clockOut, goodParts, badParts, type, comment, state) {
+    this.workOrderId = workOrderId;
+    this.lot = lot;
+    this.split = split;
+    this.sub = sub;
+    this.sequenceNumber = sequenceNumber;
+    this.resourceId = resourceId;
+    this.personId = personId;
+    this.laborTicketId = laborTicketId;
+    this.transactionDate = transactionDate;
+    this.clockIn = clockIn;
+    this.clockOut = clockOut;
+    this.goodParts = goodParts;
+    this.badParts = badParts;
+    this.type = type;
+    this.comment = comment;
+    this.state = state;
+  }
+  toRESTApiObject() {
+    return {
+      workOrderId: this.workOrderId,
+      lot: this.lot,
+      split: this.split,
+      sub: this.sub,
+      sequenceNumber: this.sequenceNumber,
+      resourceId: this.resourceId,
+      personId: this.personId,
+      laborTicketId: this.laborTicketId,
+      transactionDate: this.transactionDate,
+      clockIn: this.clockIn,
+      clockOut: this.clockOut,
+      goodParts: this.goodParts.toString(),
+      badParts: this.badParts.toString(),
+      type: this.type,
+      comment: this.comment,
+      state: this.state
+    };
+  }
+  static fromPlainObject(data) {
+    return new MMSendLaborTicket(
+      data.workOrderId || "",
+      data.lot || "",
+      data.split || "",
+      data.sub || "",
+      data.sequenceNumber || "",
+      data.resourceId || "",
+      data.personId || "",
+      data.laborTicketId || "",
+      data.transactionDate ?? null,
+      data.clockIn ?? null,
+      data.clockOut ?? null,
+      parseInt(data.goodParts || "0"),
+      parseInt(data.badParts || "0"),
+      data.type || "",
+      data.comment || "",
+      data.state || ""
+    );
+  }
+}
+let companyInfoCache = null;
+const getCompanyInfo = async () => {
+  if (companyInfoCache) {
+    return companyInfoCache;
+  }
+  try {
+    const config2 = CoreConfiguration.inst();
+    const apiUrl = config2.mmApiBaseUrl;
+    const authToken = config2.mmApiAuthToken;
+    if (!apiUrl || !authToken) {
+      throw new Error("Missing required configuration for company info fetch");
+    }
+    const client = HTTPClientFactory.getInstance({
+      baseUrl: apiUrl,
+      retryAttempts: config2.mmApiRetryAttempts
+    });
+    const response = await client.request({
+      url: "/accounts/current?includeLocation=true",
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      }
+    });
+    const userInfo = response.data;
+    if (!userInfo?.company) {
+      throw new Error("Unable to retrieve company information from API");
+    }
+    logger.info("Fetched company info from /accounts/current", {
+      locationRef: userInfo.locationRef,
+      companyId: userInfo.company.id,
+      timezone: userInfo.company.timezone
+    });
+    companyInfoCache = {
+      timezone: userInfo.company.timezone,
+      locationRef: String(userInfo.locationRef),
+      // Convert number to string
+      companyId: userInfo.company.id
+    };
+    return companyInfoCache;
+  } catch (error) {
+    throw new Error(
+      `Failed to get company info: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MMApiClient,
+  MMReceiveLaborTicket,
+  MMSendLaborTicket,
+  MMSendPart,
+  MMSendPartOperation,
+  MMSendPerson,
+  MMSendReason,
+  MMSendResource,
+  MMSendWorkOrder,
+  MMSendWorkOrderOperation,
+  getCompanyInfo
+}, Symbol.toStringTag, { value: "Module" }));
+function getUniqueRows(data, fields, sortFields) {
+  const createCompositeKey = (item) => {
+    return fields.map((field) => String(item[field])).join("|");
+  };
+  const uniqueKeys = /* @__PURE__ */ new Set();
+  const uniqueRows = [];
+  data.forEach((item) => {
+    const key = createCompositeKey(item);
+    if (!uniqueKeys.has(key)) {
+      uniqueKeys.add(key);
+      uniqueRows.push(item);
+    }
+  });
+  if (sortFields && sortFields.length > 0) {
+    uniqueRows.sort((a2, b) => {
+      for (let i = 0; i < sortFields.length; i++) {
+        const field = sortFields[i];
+        if (a2[field] < b[field]) return -1;
+        if (a2[field] > b[field]) return 1;
+      }
+      return 0;
+    });
+  }
+  return uniqueRows || [];
+}
+const removeExtraneousFields = (recordset, retainFields) => {
+  const data = recordset.map((row) => {
+    const transformedRow = {};
+    Object.keys(row).forEach((key) => {
+      if (retainFields.includes(key)) {
+        transformedRow[key] = row[key]?.toString() || "";
+      }
+    });
+    return transformedRow;
+  }) || [];
+  return data;
+};
+const getPayloadWithoutIDField = (recordset, idField) => {
+  const data = recordset.map((row) => {
+    const transformedRow = {};
+    Object.keys(row).forEach((key) => {
+      if (!idField.includes(key)) {
+        transformedRow[key] = row[key]?.toString() || "";
+      }
+    });
+    return transformedRow;
+  }) || [];
+  return data;
+};
+const trimObjectValues = (obj) => {
+  return Object.keys(obj).reduce((acc, key) => {
+    const value = obj[key];
+    acc[key] = typeof value === "string" ? value.trim() : value;
+    return acc;
+  }, {});
+};
+const cleanupNumbers = (data) => {
+  data = data.toString().replace(/[^0-9\.]+/g, "");
+  return data;
+};
+const addNewFieldFromExternalSource = (data, externalSource, externalSourceFieldName, newFieldName, defaultValue = "-") => {
+  return data.map((current) => {
+    const cacheEntry = externalSource.find(
+      (existing) => existing[externalSourceFieldName] === current[externalSourceFieldName]
+    );
+    const newFieldValue = cacheEntry?.[newFieldName] || defaultValue;
+    return {
+      ...current,
+      [newFieldName]: newFieldValue
+    };
+  });
+};
+const addNewFieldFromLookupField = (data, externalSource, lookupField, currentField, newFieldName, defaultValue = "-") => {
+  return data.map((current) => {
+    const cacheEntry = externalSource.find(
+      (existing) => existing[lookupField] === current[currentField]
+    );
+    const newFieldValue = cacheEntry?.[currentField] || defaultValue;
+    return {
+      ...current,
+      [newFieldName]: newFieldValue
+    };
+  });
+};
+const getTimezoneOffset = async () => {
+  try {
+    const config2 = CoreConfiguration.inst();
+    const apiUrl = config2.mmApiBaseUrl;
+    const authToken = config2.mmApiAuthToken;
+    if (!apiUrl || !authToken) {
+      throw new Error("Missing required configuration for timezone fetch");
+    }
+    const client = HTTPClientFactory.getInstance({
+      baseUrl: apiUrl,
+      retryAttempts: config2.mmApiRetryAttempts
+    });
+    const response = await client.request({
+      url: "/accounts/current",
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      }
+    });
+    const userInfo = response.data;
+    if (!userInfo?.company?.timezone) {
+      throw new Error("Unable to retrieve company timezone from API");
+    }
+    const timezone = userInfo.company.timezone;
+    const date = /* @__PURE__ */ new Date();
+    const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
+    const tzDate = new Date(
+      date.toLocaleString("en-US", { timeZone: timezone })
+    );
+    const offset = (tzDate.getTime() - utcDate.getTime()) / 36e5;
+    return { offset, timezone };
+  } catch (error) {
+    throw new Error(
+      `Failed to get timezone offset: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+const convertToLocalTime = (zuluTime, timezoneOffset) => {
+  if (!zuluTime) return void 0;
+  const date = new Date(zuluTime);
+  return new Date(date.getTime() + timezoneOffset * 60 * 60 * 1e3);
+};
+const formatDateWithTZOffset = (date, timezoneOffset) => {
+  if (!date) return void 0;
+  const isoDate = date.replace(" ", "T");
+  const sign = timezoneOffset >= 0 ? "+" : "-";
+  const absOffset = Math.abs(timezoneOffset);
+  const hours = Math.floor(absOffset).toString().padStart(2, "0");
+  const minutes = Math.floor(absOffset % 1 * 60).toString().padStart(2, "0");
+  return `${isoDate}${sign}${hours}:${minutes}`;
+};
+const toISOWithOffset = (date, timezoneOffset) => {
+  const sign = timezoneOffset >= 0 ? "+" : "-";
+  const abs = Math.abs(timezoneOffset);
+  const hours = Math.floor(abs);
+  const minutes = Math.round((abs - hours) * 60);
+  const pad2 = (n) => n.toString().padStart(2, "0");
+  const pad3 = (n) => n.toString().padStart(3, "0");
+  const yyyy = date.getUTCFullYear();
+  const MM = pad2(date.getUTCMonth() + 1);
+  const dd = pad2(date.getUTCDate());
+  const HH = pad2(date.getUTCHours());
+  const mm = pad2(date.getUTCMinutes());
+  const ss = pad2(date.getUTCSeconds());
+  const SSS = pad3(date.getUTCMilliseconds());
+  const off = `${sign}${pad2(hours)}:${pad2(minutes)}`;
+  return `${yyyy}-${MM}-${dd}T${HH}:${mm}:${ss}.${SSS}${off}`;
+};
+function calculateTimeDifferenceInHours(startTime, endTime, timezoneOffset) {
+  if (!startTime || !endTime) return 0;
+  const localStartTime = convertToLocalTime(startTime, timezoneOffset);
+  const localEndTime = convertToLocalTime(endTime, timezoneOffset);
+  if (!localStartTime || !localEndTime) return 0;
+  const startHours = localStartTime.getHours();
+  const startMinutes = localStartTime.getMinutes();
+  const startSeconds = localStartTime.getSeconds();
+  const endHours = localEndTime.getHours();
+  const endMinutes = localEndTime.getMinutes();
+  const endSeconds = localEndTime.getSeconds();
+  const startTotalSeconds = startHours * 3600 + startMinutes * 60 + startSeconds;
+  const endTotalSeconds = endHours * 3600 + endMinutes * 60 + endSeconds;
+  if (endTotalSeconds > startTotalSeconds) {
+    return Number(((endTotalSeconds - startTotalSeconds) / 3600).toFixed(3));
+  }
+  return 0;
+}
+const getSecondsOfDay = (timestamp) => {
+  if (!timestamp) return null;
+  const time = new Date(timestamp);
+  const utcHours = time.getUTCHours();
+  const utcMinutes = time.getUTCMinutes();
+  const utcSeconds = time.getUTCSeconds();
+  return (utcHours * 3600 + utcMinutes * 60 + utcSeconds).toString();
+};
+const applyTimezoneOffsetsToFields = (item, fields, timezoneOffset) => {
+  const transformed = { ...item };
+  fields.forEach((field) => {
+    if (transformed[field] && transformed[field].trim()) {
+      const formattedDate = formatDateWithTZOffset(
+        transformed[field],
+        timezoneOffset
+      );
+      transformed[field] = formattedDate || "";
+    } else {
+      transformed[field] = "";
+    }
+  });
+  return transformed;
+};
+const getTimezoneOffsetAndPersist = async (params = {
+  maxRetries: 36e3,
+  // Retry for 10 hours before giving up.
+  retryIntervalMs: 1e4
+}) => {
+  let success = false;
+  let retries = 0;
+  logger.info(
+    "Acquiring the timezone offset and timezone name from MachineMetrics and storing in cache"
+  );
+  while (!success && retries < params.maxRetries) {
+    try {
+      const { offset, timezone } = await getTimezoneOffset();
+      logger.info(`Timezone offset: ${offset} hours, timezone: ${timezone}`);
+      setTimezoneOffsetInCache(offset);
+      setTimezoneNameInCache(timezone);
+      success = true;
+    } catch (error) {
+      logger.error("Error getting timezone offset:", error);
+      logger.info(`Retrying in ${params.retryIntervalMs / 1e3} seconds...`);
+      await new Promise(
+        (resolve) => setTimeout(resolve, params.retryIntervalMs)
+      );
+      retries++;
+    }
+  }
+  if (!success) {
+    throw new Error(
+      `Failed to get the timezone offset after ${params.maxRetries} retries`
+    );
+  }
+};
+const DEFAULT_RECORD_TRACKING_TABLE_NAME = "record_tracking";
+class RecordTrackingManager {
+  db;
+  constructor() {
+    this.db = knex(config.local);
+  }
+  async updateRecord(record) {
+    if (record.lastValue && record.recordId) {
+      const recordUpdated = await this.db(DEFAULT_RECORD_TRACKING_TABLE_NAME).where({ entityType: record.entityType }).update(record);
+      if (recordUpdated < 1) {
+        await this.db(DEFAULT_RECORD_TRACKING_TABLE_NAME).insert(record);
+      }
+    }
+  }
+  async getTrackingRecord(type) {
+    return await this.db(DEFAULT_RECORD_TRACKING_TABLE_NAME).select("*").where({ entityType: type.toString() });
+  }
+  async destroy() {
+    return this.db.destroy();
+  }
+}
+class BatchCacheManager {
+  cacheManager;
+  constructor(options) {
+    this.cacheManager = new HashedCacheManager({
+      ttl: options?.ttl,
+      tableName: options?.tableName
+    });
+  }
+  /**
+   * Checks a batch of objects against the cache and separates them into duplicates and non-duplicates
+   * @param type The type of objects
+   * @param objects Array of objects to check
+   * @returns Object containing arrays of duplicate and non-duplicate objects
+   */
+  async dedupeBatch(type, objects) {
+    const result = {
+      duplicates: [],
+      nonDuplicates: []
+    };
+    for (const object of objects) {
+      const hasChanged = await this.cacheManager.hasChanged(type, object);
+      if (hasChanged) {
+        result.nonDuplicates.push(object);
+      } else {
+        result.duplicates.push(object);
+      }
+    }
+    return result;
+  }
+  /**
+   * Stores a batch of objects in the cache
+   * @param type The type of objects
+   * @param objects Array of objects to store
+   */
+  async storeBatch(type, objects) {
+    let totalInserted = 0;
+    for (const object of objects) {
+      if (await this.cacheManager.store(type, object)) {
+        totalInserted++;
+      }
+    }
+    return { totalInserted };
+  }
+  /**
+   * Removes objects from the cache
+   * @param type The type of objects
+   * @param objects Array of objects to remove
+   */
+  async removeObjects(type, objects) {
+    for (const object of objects) {
+      await this.cacheManager.removeRecord(type, object);
+    }
+  }
+  /**
+   * Gets all records of a specific type
+   */
+  async getRecordsByType(type) {
+    return this.cacheManager.getRecordsByType(type);
+  }
+  /**
+   * Removes all records of a specific type
+   */
+  async removeRecordsByType(type) {
+    return this.cacheManager.removeRecordsByType(type);
+  }
+  /**
+   * Clears all records from the cache
+   */
+  async clear() {
+    return this.cacheManager.clear();
+  }
+  /**
+   * Cleans up resources
+   */
+  async destroy() {
+    return this.cacheManager.destroy();
+  }
+}
+function convertLaborTicketToLocalTimezone(laborTicket, timezoneOffset) {
+  const timeFields = [
+    "clockIn",
+    "clockOut",
+    "transactionDate",
+    "createdAt",
+    "updatedAt",
+    "workOrderOperationClosedDate"
+  ];
+  timeFields.forEach((field) => {
+    const localTime = convertToLocalTime(laborTicket[field], timezoneOffset);
+    laborTicket[field] = localTime ? toISOWithOffset(localTime, timezoneOffset) : null;
+  });
+  return laborTicket;
+}
+class LaborTicketERPSynchronizer {
+  /**
+   * Synchronizes updated labor tickets from MachineMetrics to an ERP system
+   */
+  static async syncToERP(connectorType, connector) {
+    try {
+      const mmApiClient = new MMApiClient();
+      const failedLaborTicketRefs = [];
+      await mmApiClient.initializeCheckpoint({
+        system: connectorType,
+        table: "labor_tickets",
+        checkpointType: "export",
+        checkpointValue: {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      const fallbackTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const laborTicketsUpdates = await mmApiClient.fetchLaborTicketUpdates({
+        system: connectorType,
+        checkpointType: "export"
+      });
+      if (laborTicketsUpdates.length === 0) {
+        logger.info("syncLaborTicketsToERP:No updated labor tickets found");
+        return;
+      }
+      logger.info(
+        `ToERP: Found ${laborTicketsUpdates.length} Labor Ticket Ids and Refs to process`,
+        {
+          laborTickets: laborTicketsUpdates.map(
+            (ticket) => ({
+              ref: ticket.laborTicketRef,
+              id: ticket.laborTicketId
+            })
+          )
+        }
+      );
+      const mostRecentUpdate = laborTicketsUpdates.reduce(
+        (latest, ticket) => {
+          if (!latest || !ticket.updatedAt) return latest;
+          return new Date(ticket.updatedAt) > new Date(latest) ? ticket.updatedAt : latest;
+        },
+        null
+      );
+      await Promise.all(
+        laborTicketsUpdates.map(async (laborTicket) => {
+          if (!laborTicket.laborTicketRef) {
+            logger.error(
+              "syncLaborTicketsToERP: laborTicketRef is not set for laborTicket pulled from MM:",
+              { laborTicket }
+            );
+            return void 0;
+          }
+          try {
+            return await this.processLaborTicket(
+              connector,
+              mmApiClient,
+              laborTicket
+            );
+          } catch (error) {
+            failedLaborTicketRefs.push(laborTicket.laborTicketRef);
+            logger.error(
+              `syncLaborTicketsToERP: Error processing laborTicketRef ${laborTicket.laborTicketRef}:`,
+              { error }
+            );
+            return void 0;
+          }
+        })
+      );
+      logger.info(
+        `syncLaborTicketsToERP: ${failedLaborTicketRefs.length} failed labor ticket ids`
+      );
+      if (failedLaborTicketRefs.length > 0) {
+        logger.info(
+          `syncLaborTicketsToERP: Reporting ${failedLaborTicketRefs.length} labor ticket failures:`,
+          {
+            failedLaborTicketRefs
+          }
+        );
+        const addFailedResult = await mmApiClient.addFailedLaborTicketRefs(
+          connectorType,
+          failedLaborTicketRefs
+        );
+        logger.info("syncLaborTicketsToERP: addFailedResult:", {
+          addFailedResult
+        });
+      }
+      mmApiClient.saveCheckpoint({
+        system: connectorType,
+        table: "labor_tickets",
+        checkpointType: "export",
+        checkpointValue: {
+          timestamp: mostRecentUpdate || fallbackTimestamp
+        }
+      });
+    } catch (error) {
+      logger.error("syncLaborTicketsToERP: Error:", error);
+    }
+  }
+  /**
+   * Retries labor tickets that have failed to be created or updated in the ERP during the sync
+   */
+  static async retryFailed(connectorType, connector) {
+    try {
+      const mmApiClient = new MMApiClient();
+      const successLaborTicketIds = [];
+      const laborTickets = await mmApiClient.fetchFailedLaborTickets(connectorType);
+      if (laborTickets.length === 0) {
+        logger.info("retryFailedLaborTickets: No failed labor tickets found");
+        return;
+      }
+      logger.info(
+        "retryFailedLaborTickets: Failed Labor Tickets count:" + laborTickets.length
+      );
+      await Promise.all(
+        laborTickets.map(async (laborTicket) => {
+          if (!laborTicket.laborTicketRef) {
+            logger.error(
+              "retryFailedLaborTickets: laborTicketRef is not set for laborTicket pulled from MM:",
+              { laborTicket }
+            );
+            return void 0;
+          }
+          try {
+            const laborTicketResult = await this.processLaborTicket(
+              connector,
+              mmApiClient,
+              laborTicket
+            );
+            successLaborTicketIds.push(laborTicket.laborTicketRef);
+            return laborTicketResult;
+          } catch (error) {
+            logger.error(
+              "retryFailedLaborTickets: Error processing laborTicketRef:",
+              { laborTicketRef: laborTicket.laborTicketRef, error }
+            );
+            return void 0;
+          }
+        })
+      );
+      if (successLaborTicketIds.length > 0) {
+        logger.info("Deleting failed labor ticket ids:", {
+          successLaborTicketIds
+        });
+        const deleteFailedResult = await mmApiClient.deleteFailedLaborTicketIds(
+          connectorType,
+          successLaborTicketIds
+        );
+        logger.info("deleteFailedResult:", { deleteFailedResult });
+      }
+    } catch (error) {
+      logger.error("retryFailedLaborTickets: Error:", error);
+    }
+  }
+  // ============================================================================
+  // PRIVATE HELPER METHODS
+  // ============================================================================
+  static async writeLaborTicketIdToMM(mmApiClient, laborTicket, laborTicketResult) {
+    const updateRefAPIResponse = await mmApiClient.updateLaborTicketIdByRef(
+      laborTicket.laborTicketRef,
+      laborTicketResult.laborTicketId
+    );
+    logger.info(
+      `Updated laborTicketId ${laborTicketResult.laborTicketId} for laborTicketRef ${laborTicket.laborTicketRef} in MM:`,
+      { updateRefAPIResponse }
+    );
+  }
+  static async processLaborTicket(connector, mmApiClient, laborTicket) {
+    let laborTicketResult;
+    laborTicketResult = convertLaborTicketToLocalTimezone(
+      laborTicket,
+      getCachedTimezoneOffset()
+    );
+    logger.info(
+      `processing laborTicket, id=${laborTicket.laborTicketId}, ref=${laborTicket.laborTicketRef}`
+    );
+    logger.debug({ laborTicket });
+    if (!laborTicket.laborTicketId) {
+      const { laborTicket: laborTicketResult2, erpUid } = await connector.createLaborTicketInERP(laborTicket);
+      laborTicketResult2.laborTicketId = erpUid;
+      await this.writeLaborTicketIdToMM(
+        mmApiClient,
+        laborTicket,
+        laborTicketResult2
+      );
+    } else {
+      laborTicketResult = await connector.updateLaborTicketInERP(laborTicket);
+    }
+    logger.info("ToERP: laborTicket update result:", {
+      laborTicketResult: laborTicketResult || "Failed to create/update labor ticket",
+      laborTicketRef: laborTicket.laborTicketRef,
+      operation: laborTicket.laborTicketId ? "update" : "create"
+    });
+    return laborTicketResult;
+  }
+}
+class EntityTransformer {
+  // ============================================================================
+  // PUBLIC INTERFACE METHODS
+  // ============================================================================
+  /**
+   * Extracts the primary key from a record based on entity type
+   * @param entityType The type of entity being processed
+   * @param record The record to extract primary key from
+   * @returns A string representation of the primary key
+   * @throws Error if primary key fields are missing or invalid
+   */
+  static extractPrimaryKey(entityType, record) {
+    switch (entityType) {
+      case ERPObjType.PERSONS:
+        return this.extractPersonKey(record);
+      case ERPObjType.RESOURCES:
+        return this.extractResourceKey(record);
+      case ERPObjType.PARTS:
+        return this.extractPartKey(record);
+      case ERPObjType.PART_OPERATION:
+        return this.extractPartOperationKey(record);
+      case ERPObjType.WORK_ORDERS:
+        return this.extractWorkOrderKey(record);
+      case ERPObjType.WORK_ORDER_OPERATIONS:
+        return this.extractWorkOrderOperationKey(record);
+      case ERPObjType.LABOR_TICKETS:
+        return this.extractLaborTicketKey(record);
+      case ERPObjType.REASONS:
+        return this.extractReasonKey(record);
+      default:
+        throw new Error(
+          `Unsupported entity type for primary key extraction: ${entityType}`
+        );
+    }
+  }
+  /**
+   * Reconstructs a typed object from plain data based on entity type
+   * @param entityType The type of entity being processed
+   * @param plainData The plain data object containing entity fields
+   * @returns A properly typed IToRESTApiObject instance
+   * @throws Error if the entity type is not supported
+   */
+  static reconstructFromPlainData(entityType, plainData) {
+    switch (entityType) {
+      case ERPObjType.PERSONS:
+        return this.reconstructPerson(plainData);
+      case ERPObjType.RESOURCES:
+        return this.reconstructResource(plainData);
+      case ERPObjType.PARTS:
+        return this.reconstructPart(plainData);
+      case ERPObjType.PART_OPERATION:
+        return this.reconstructPartOperation(plainData);
+      case ERPObjType.WORK_ORDERS:
+        return this.reconstructWorkOrder(plainData);
+      case ERPObjType.WORK_ORDER_OPERATIONS:
+        return this.reconstructWorkOrderOperation(plainData);
+      case ERPObjType.LABOR_TICKETS:
+        return this.reconstructLaborTicket(plainData);
+      case ERPObjType.REASONS:
+        return this.reconstructReason(plainData);
+      default:
+        throw new Error(
+          `Unsupported entity type for reconstruction: ${entityType}`
+        );
+    }
+  }
+  /**
+   * Reconstructs multiple typed objects from plain data based on entity type
+   * @param entityType The type of entity being processed
+   * @param plainDataArray Array of plain data objects containing entity fields
+   * @returns Array of properly typed IToRESTApiObject instances
+   */
+  static reconstructMultipleFromPlainData(entityType, plainDataArray) {
+    return plainDataArray.map(
+      (plainData) => this.reconstructFromPlainData(entityType, plainData)
+    );
+  }
+  // ============================================================================
+  // PRIVATE ENTITY-SPECIFIC KEY EXTRACTION METHODS
+  // ============================================================================
+  static extractPersonKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    return this.validateAndExtractKey(restApiObject, ["personId"], "PERSONS", [
+      "personId"
+    ]);
+  }
+  static extractResourceKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    return this.validateAndExtractKey(
+      restApiObject,
+      ["resourceId"],
+      "RESOURCES",
+      ["resourceId"]
+    );
+  }
+  static extractPartKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    return this.validateAndExtractKey(
+      restApiObject,
+      ["partNumber", "partRevision", "method"],
+      "PARTS",
+      ["partNumber"]
+    );
+  }
+  static extractPartOperationKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    return this.validateAndExtractKey(
+      restApiObject,
+      ["partNumber", "partRevision", "method", "sequenceNumber"],
+      "PART_OPERATION",
+      ["partNumber", "sequenceNumber"]
+    );
+  }
+  static extractWorkOrderKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    return this.validateAndExtractKey(
+      restApiObject,
+      ["workOrderId", "lot", "split", "sub"],
+      "WORK_ORDERS",
+      ["workOrderId"]
+    );
+  }
+  static extractWorkOrderOperationKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    return this.validateAndExtractKey(
+      restApiObject,
+      ["workOrderId", "lot", "split", "sub", "sequenceNumber"],
+      "WORK_ORDER_OPERATIONS",
+      ["workOrderId", "sequenceNumber"]
+    );
+  }
+  static extractLaborTicketKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    if (restApiObject.laborTicketId) {
+      return this.validateAndExtractKey(
+        restApiObject,
+        ["laborTicketId"],
+        "LABOR_TICKETS",
+        ["laborTicketId"]
+      );
+    } else {
+      return this.validateAndExtractKey(
+        restApiObject,
+        [
+          "workOrderId",
+          "lot",
+          "split",
+          "sub",
+          "sequenceNumber",
+          "resourceId",
+          "personId"
+        ],
+        "LABOR_TICKETS",
+        ["workOrderId", "sequenceNumber", "resourceId", "personId"]
+      );
+    }
+  }
+  static extractReasonKey(record) {
+    const restApiObject = record.toRESTApiObject();
+    return this.validateAndExtractKey(restApiObject, ["reasonId"], "REASONS", [
+      "reasonId"
+    ]);
+  }
+  // ============================================================================
+  // PRIVATE ENTITY-SPECIFIC RECONSTRUCTION METHODS
+  // ============================================================================
+  static reconstructPerson(plainData) {
+    return MMSendPerson.fromPlainObject(plainData);
+  }
+  static reconstructResource(plainData) {
+    return MMSendResource.fromPlainObject(plainData);
+  }
+  static reconstructPart(plainData) {
+    return MMSendPart.fromPlainObject(plainData);
+  }
+  static reconstructPartOperation(plainData) {
+    return MMSendPartOperation.fromPlainObject(plainData);
+  }
+  static reconstructWorkOrder(plainData) {
+    return MMSendWorkOrder.fromPlainObject(plainData);
+  }
+  static reconstructWorkOrderOperation(plainData) {
+    return MMSendWorkOrderOperation.fromPlainObject(plainData);
+  }
+  static reconstructLaborTicket(plainData) {
+    return MMSendLaborTicket.fromPlainObject(plainData);
+  }
+  static reconstructReason(plainData) {
+    return MMSendReason.fromPlainObject(plainData);
+  }
+  // ============================================================================
+  // SHARED UTILITY METHODS
+  // ============================================================================
+  /**
+   * Helper method to validate and extract primary key components
+   * @param restApiObject The REST API object representation
+   * @param keyFields The fields that make up the primary key
+   * @param entityTypeName The entity type name for error messages
+   * @param requiredFields The fields that must be non-empty (others can be empty)
+   * @returns Combined primary key string
+   * @throws Error if any required field is missing or null
+   */
+  static validateAndExtractKey(restApiObject, keyFields, entityTypeName, requiredFields) {
+    const keyValues = [];
+    for (const field of keyFields) {
+      const value = restApiObject[field];
+      if (requiredFields.includes(field)) {
+        if (value === null || value === void 0 || value === "") {
+          throw new Error(
+            `Primary key field '${field}' is missing or empty for entity type ${entityTypeName}`
+          );
+        }
+      }
+      keyValues.push(value || "");
+    }
+    return keyValues.join("|");
+  }
+}
+class ErrorProcessor {
+  /**
+   * Creates a set of primary keys for all failed records from batch errors
+   * @param entityType The type of entity being processed
+   * @param batchErrors Array of batch errors containing failed entities
+   * @returns Set of primary keys for failed records
+   */
+  static createFailedRecordKeySet(entityType, batchErrors) {
+    const failedKeySet = /* @__PURE__ */ new Set();
+    batchErrors.forEach((batchError) => {
+      batchError.affectedEntities.forEach((affectedEntity) => {
+        try {
+          const primaryKey = EntityTransformer.extractPrimaryKey(
+            entityType,
+            affectedEntity
+          );
+          failedKeySet.add(primaryKey);
+        } catch (error) {
+          logger.warn(
+            `Failed to extract primary key from error entity: ${error}`
+          );
+        }
+      });
+    });
+    return failedKeySet;
+  }
+  /**
+   * Filters out failed records, returning only successful ones
+   * @param entityType The type of entity being processed
+   * @param allRecords All records (typed objects) that were sent to the API
+   * @param failedKeySet Set of primary keys for records that failed
+   * @returns Array of records that succeeded
+   */
+  static filterSuccessfulRecords(entityType, allRecords, failedKeySet) {
+    const successfulRecords = [];
+    allRecords.forEach((record) => {
+      try {
+        const primaryKey = EntityTransformer.extractPrimaryKey(
+          entityType,
+          record
+        );
+        if (!failedKeySet.has(primaryKey)) {
+          successfulRecords.push(record);
+        }
+      } catch (error) {
+        logger.warn(
+          `Failed to extract primary key from record during filtering: ${error}`
+        );
+      }
+    });
+    return successfulRecords;
+  }
+  /**
+   * Orchestrates the caching of successful records on partial failure
+   * @param entityType The type of entity being processed
+   * @param toProcess All records that were sent to the API (all are now guaranteed to be typed objects)
+   * @param batchErrors Array of batch errors containing failed entities
+   * @param batchCacheManager The cache manager instance
+   */
+  static async cacheSuccessfulRecordsOnPartialFailure(entityType, toProcess, batchErrors, batchCacheManager) {
+    const failedKeySet = this.createFailedRecordKeySet(entityType, batchErrors);
+    const successfulRecords = this.filterSuccessfulRecords(
+      entityType,
+      toProcess,
+      failedKeySet
+    );
+    logger.info(
+      `Caching ${successfulRecords.length} successful records out of ${toProcess.length} total records`
+    );
+    if (successfulRecords.length > 0) {
+      await batchCacheManager.storeBatch(entityType, successfulRecords);
+    }
+  }
+  /**
+   * Extracts error count and batch errors from MM API response for partial failures (HTTP 207)
+   * This supports all entities, including the slightly different format for labor tickets.
+   * In case of labor tickets, the updateErrors and insertErrors arrays are combined into affectedEntities.
+   * @param mmApiResponse The full MM API response object
+   * @param entityType The type of entity being processed (determines response structure)
+   * @returns Object containing errorCount and batchErrors
+   * See MM207NonLaborTicketResponse and MM207LaborTicketResponse for response structure details
+   */
+  static extractErrorDetails(mmApiResponse, entityType) {
+    const data = mmApiResponse.data;
+    let allErrors = [];
+    if (entityType === ERPObjType.LABOR_TICKETS) {
+      const updateErrors = data?.updateErrors || [];
+      const insertErrors = data?.insertErrors || [];
+      if (!data?.updateErrors && !data?.insertErrors) {
+        logger.warn(
+          "Labor tickets partial success response missing both updateErrors and insertErrors arrays"
+        );
+      }
+      allErrors = [...updateErrors, ...insertErrors];
+    } else {
+      const errors = data?.errors || [];
+      if (!data?.errors) {
+        logger.warn(
+          `${entityType} partial success response missing errors array`
+        );
+      }
+      allErrors = errors;
+    }
+    const batchErrors = allErrors.filter(
+      (error) => {
+        return error.batchData && error.batchData.length > 0;
+      }
+    ).map(
+      (error) => {
+        const typedErrorEntities = (error.batchData || []).map((entity) => {
+          if (typeof entity === "object" && entity !== null && "toRESTApiObject" in entity && typeof entity.toRESTApiObject === "function") {
+            return entity;
+          } else {
+            return EntityTransformer.reconstructFromPlainData(
+              entityType,
+              entity
+            );
+          }
+        });
+        return {
+          message: error.message,
+          affectedEntities: typedErrorEntities
+        };
+      }
+    );
+    const errorCount = batchErrors.reduce((total, batchError) => {
+      return total + batchError.affectedEntities.length;
+    }, 0);
+    return {
+      errorCount,
+      batchErrors
+    };
+  }
+  /**
+   * Extracts error details from a 500 HTTP exception when it contains structured error data
+   * @param exception The caught exception from MM API call
+   * @param entityType The type of entity being processed
+   * @returns Object containing errorCount and batchErrors, or null if not a structured 500 error
+   * See MM500NonLaborTicketException and MM500LaborTicketException for exception structure details
+   */
+  static extractErrorDetailsFrom500Exception(exception, entityType) {
+    try {
+      const ex = exception;
+      const data = ex?.data;
+      logger.info(
+        "writeEntitiesToMM: Analyzing 500 exception structure for diagnostic purposes",
+        {
+          status: ex?.status,
+          code: ex?.code,
+          hasResponseData: !!data,
+          responseDataKeys: data ? Object.keys(data) : [],
+          errorMessage: data?.error,
+          hasMessageObject: !!data?.message,
+          messageObjectKeys: data?.message ? Object.keys(data.message) : [],
+          entityType,
+          exceptionType: typeof exception,
+          exceptionKeys: ex ? Object.keys(ex) : []
+        }
+      );
+      if (ex?.status !== 500 || typeof data?.error !== "string" || !data.error.startsWith("Failed to import")) {
+        logger.info(
+          "writeEntitiesToMM: Not a structured 500 error - will re-throw exception as-is",
+          {
+            status: ex?.status,
+            errorMessage: data?.error,
+            expectedStatus: 500,
+            expectedMessagePrefix: "Failed to import"
+          }
+        );
+        return null;
+      }
+      logger.info(
+        "writeEntitiesToMM: Detected structured 500 error - extracting error details"
+      );
+      const messageObject = data?.message;
+      if (!messageObject) {
+        logger.warn(
+          "writeEntitiesToMM: Structured 500 error missing message object"
+        );
+        return null;
+      }
+      let allErrors = [];
+      if (entityType === ERPObjType.LABOR_TICKETS) {
+        const updateErrors = Array.isArray(messageObject?.updateErrors) ? messageObject.updateErrors : [];
+        const insertErrors = Array.isArray(messageObject?.insertErrors) ? messageObject.insertErrors : [];
+        logger.info("writeEntitiesToMM: Processing labor tickets 500 error", {
+          updateErrorsCount: updateErrors.length,
+          insertErrorsCount: insertErrors.length
+        });
+        if (updateErrors.length === 0 && insertErrors.length === 0) {
+          logger.warn(
+            "writeEntitiesToMM: Labor tickets 500 error missing both updateErrors and insertErrors arrays"
+          );
+        }
+        allErrors = [...updateErrors, ...insertErrors];
+      } else {
+        const errors = Array.isArray(messageObject?.errors) ? messageObject.errors : [];
+        logger.info("writeEntitiesToMM: Processing regular entity 500 error", {
+          errorsCount: errors.length
+        });
+        if (errors.length === 0) {
+          logger.warn(
+            `writeEntitiesToMM: ${entityType} 500 error missing errors array`
+          );
+        }
+        allErrors = errors;
+      }
+      const batchErrors = allErrors.filter((error) => {
+        const err = error;
+        return Array.isArray(err?.batchData) && err.batchData.length > 0;
+      }).map((error) => {
+        const err = error;
+        const batchData = err?.batchData;
+        const typedErrorEntities = (batchData || []).map((entity) => {
+          if (typeof entity === "object" && entity !== null && "toRESTApiObject" in entity && typeof entity.toRESTApiObject === "function") {
+            return entity;
+          } else {
+            return EntityTransformer.reconstructFromPlainData(
+              entityType,
+              entity
+            );
+          }
+        });
+        return {
+          message: typeof err?.message === "string" ? err.message : "Unknown error",
+          affectedEntities: typedErrorEntities
+        };
+      });
+      const errorCount = batchErrors.reduce((total, batchError) => {
+        return total + batchError.affectedEntities.length;
+      }, 0);
+      logger.info("writeEntitiesToMM: Extracted 500 error details", {
+        batchErrorsCount: batchErrors.length,
+        totalErrorCount: errorCount,
+        entityType
+      });
+      return {
+        errorCount,
+        batchErrors
+      };
+    } catch (error) {
+      logger.error(
+        "writeEntitiesToMM: Failed to parse 500 exception structure safely",
+        {
+          error: error instanceof Error ? error.message : String(error),
+          exceptionType: typeof exception,
+          entityType
+        }
+      );
+      return null;
+    }
+  }
+}
+class MMEntityProcessor {
+  /**
+   * Writes entities to MM API with deduplication and caching
+   */
+  static async writeEntities(entityType, mmRecords, batchCacheManager) {
+    const { toProcess, result } = await this._prepareAndDedupe(
+      entityType,
+      mmRecords,
+      batchCacheManager
+    );
+    if (toProcess.length === 0) {
+      result.message = "All records were deduplicated locally - no records sent to MM API";
+      return result;
+    }
+    let mmApiResponse;
+    try {
+      mmApiResponse = await this._sendToAPI(entityType, toProcess);
+    } catch (exception) {
+      this._handleException(exception, entityType, result);
+    }
+    return await this._handleResponse(
+      mmApiResponse,
+      entityType,
+      toProcess,
+      result,
+      batchCacheManager
+    );
+  }
+  // ============================================================================
+  // PRIVATE HELPER METHODS
+  // ============================================================================
+  /**
+   * Deduplicates records against cache
+   * Returns the records to process and the result object
+   * If the batchCacheManager is provided, the records are deduplicated against the cache
+   * If the batchCacheManager is not provided, the records are not deduplicated
+   */
+  static async _prepareAndDedupe(entityType, mmRecords, batchCacheManager) {
+    let toProcess = [];
+    const result = {
+      message: "",
+      upsertedEntities: 0,
+      localDedupeCount: 0,
+      apiDedupeCount: 0
+    };
+    if (batchCacheManager) {
+      const { nonDuplicates, duplicates } = await batchCacheManager.dedupeBatch(entityType, mmRecords);
+      toProcess = nonDuplicates;
+      result.localDedupeCount = duplicates.length;
+    } else {
+      toProcess = mmRecords;
+    }
+    return { toProcess, result };
+  }
+  /**
+   * Sends records to MM API
+   */
+  static async _sendToAPI(entityType, toProcess) {
+    const mmApiClient = new MMApiClient();
+    switch (entityType) {
+      case ERPObjType.PERSONS:
+        return await mmApiClient.sendPersonsToMM(toProcess);
+      case ERPObjType.RESOURCES:
+        return await mmApiClient.sendResourcesToMM(
+          toProcess
+        );
+      case ERPObjType.PARTS:
+        return await mmApiClient.sendPartsToMM(toProcess);
+      case ERPObjType.PART_OPERATION:
+        return await mmApiClient.sendPartOperationsToMM(
+          toProcess
+        );
+      case ERPObjType.WORK_ORDERS:
+        return await mmApiClient.sendWorkOrdersToMM(
+          toProcess
+        );
+      case ERPObjType.WORK_ORDER_OPERATIONS:
+        return await mmApiClient.sendWorkOrderOperationsToMM(
+          toProcess
+        );
+      case ERPObjType.LABOR_TICKETS:
+        return await mmApiClient.sendLaborTicketsToMM(
+          toProcess
+        );
+      case ERPObjType.REASONS:
+        return await mmApiClient.sendReasonsToMM(toProcess);
+      default:
+        throw new Error(`Unknown entity type: ${entityType}`);
+    }
+  }
+  /**
+   * Handles exceptions from API calls, converting structured 500 errors to MMBatchValidationError
+   * @throws MMBatchValidationError for structured 500 errors
+   * @throws The original exception for all other errors
+   */
+  static _handleException(exception, entityType, result) {
+    const structuredCompleteErrorSet = ErrorProcessor.extractErrorDetailsFrom500Exception(exception, entityType);
+    if (structuredCompleteErrorSet) {
+      const ex = exception;
+      const data = ex?.data;
+      const errorMessage = typeof data?.error === "string" ? data.error : "All entities failed to import";
+      throw new MMBatchValidationError({
+        message: errorMessage,
+        upsertedEntities: 0,
+        localDedupeCount: result.localDedupeCount,
+        apiDedupeCount: 0,
+        errorCount: structuredCompleteErrorSet.errorCount,
+        httpStatus: exception.status,
+        batchErrors: structuredCompleteErrorSet.batchErrors
+      });
+    }
+    throw exception;
+  }
+  /**
+   * Handles the MM API response based on HTTP status code, caching successful records
+   * and throwing exceptions for partial failures
+   *
+   * @returns The final result for success cases
+   * @throws MMBatchValidationError for partial success cases
+   * @throws Error for unknown status codes
+   */
+  static async _handleResponse(mmApiResponse, entityType, toProcess, result, batchCacheManager) {
+    if (mmApiResponse.httpStatus === 200) {
+      if (batchCacheManager) {
+        await batchCacheManager.storeBatch(entityType, toProcess);
+      }
+      if (entityType === ERPObjType.LABOR_TICKETS) {
+        const success = mmApiResponse;
+        result.message = success.message || "Entities processed successfully";
+        result.upsertedEntities = (success.updated || 0) + (success.inserted || 0);
+      } else {
+        const success = mmApiResponse;
+        result.message = success.message || "Entities processed successfully";
+        result.upsertedEntities = success.affectedRows || 0;
+      }
+      result.apiDedupeCount = toProcess.length - result.upsertedEntities;
+      return result;
+    } else if (mmApiResponse.httpStatus === 207) {
+      const partialResponse = mmApiResponse;
+      const { errorCount, batchErrors } = ErrorProcessor.extractErrorDetails(
+        partialResponse,
+        entityType
+      );
+      if (batchCacheManager) {
+        await ErrorProcessor.cacheSuccessfulRecordsOnPartialFailure(
+          entityType,
+          toProcess,
+          batchErrors,
+          batchCacheManager
+        );
+      }
+      let upsertedEntities = 0;
+      if (entityType === ERPObjType.LABOR_TICKETS) {
+        const partial = partialResponse;
+        upsertedEntities = (partial.data.updated || 0) + (partial.data.inserted || 0);
+      } else {
+        const partial = partialResponse;
+        upsertedEntities = partial.data.affectedRows || 0;
+      }
+      throw new MMBatchValidationError({
+        message: partialResponse.message || "Entities processed with partial failures",
+        upsertedEntities,
+        localDedupeCount: result.localDedupeCount,
+        apiDedupeCount: toProcess.length - upsertedEntities - errorCount,
+        errorCount,
+        httpStatus: mmApiResponse.httpStatus,
+        batchErrors
+      });
+    } else {
+      throw new Error(
+        `writeEntitiesToMM: Unknown HTTP status code: ${mmApiResponse.httpStatus}. An exception was expected.`
+      );
+    }
+  }
+}
+const mmEntityProcessor = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MMEntityProcessor
+}, Symbol.toStringTag, { value: "Module" }));
+class MMBatchValidationError extends Error {
+  upsertedEntities;
+  localDedupeCount;
+  apiDedupeCount;
+  errorCount;
+  httpStatus;
+  batchErrors;
+  constructor(options) {
+    super(options.message);
+    this.name = "MMBatchValidationError";
+    this.upsertedEntities = options.upsertedEntities;
+    this.localDedupeCount = options.localDedupeCount;
+    this.apiDedupeCount = options.apiDedupeCount;
+    this.errorCount = options.errorCount;
+    this.httpStatus = options.httpStatus;
+    this.batchErrors = options.batchErrors;
+  }
+}
+class StandardProcessDrivers {
+  /**
+   * Synchronizes updated labor tickets from MachineMetrics to an ERP system:
+   *
+   * Initializes a checkpoint that tracks the last time labor tickets were synced,
+   * fetches labor tickets from MM and converts them to the company timezone,
+   * creates or updates the labor ticket in the ERP via connector-specific implementations,
+   * updates the labor ticket id in MM on newly created labor tickets,
+   * and saves the checkpoint
+   */
+  static async syncLaborTicketsToERP(connectorType, connector) {
+    return LaborTicketERPSynchronizer.syncToERP(connectorType, connector);
+  }
+  /**
+   * Retries labor tickets that have failed to be created or updated in the ERP during the sync:
+   *
+   * Fetches failed labor tickets from MM, processes them, and updates the labor ticket id in MM.
+   * If the labor ticket is successfully created or updated, it is added to the list of successful labor ticket ids,
+   * which are then deleted from the list of failed labor ticket ids.
+   */
+  static async retryFailedLaborTickets(connectorType, connector) {
+    return LaborTicketERPSynchronizer.retryFailed(connectorType, connector);
+  }
+  /**
+   * Writes a batch of records to MM for a specific entity type by:
+   * 1. Deduplicating against cached records (localDedupeCount)
+   * 2. Sending non-duplicate records to the MM API (apiDedupeCount)
+   * 3. Storing successful records in cache
+   *
+   * An example usage pattern including comprehensive error handling:
+   * ```
+   * try {
+   *   const result = await StandardProcessDrivers.writeEntitiesToMM(
+   *     'WorkOrders',
+   *     workOrderRecords,
+   *     batchCacheManager
+   *   );
+   *
+   *   // HTTP 200 - Complete success
+   *   console.log(`✅ Success: ${result.message}`);
+   *   console.log(`📊 Metrics: ${result.upsertedEntities} upserted, ${result.localDedupeCount} locally deduplicated, ${result.apiDedupeCount} API deduplicated`);
+   *
+   * } catch (error) {
+   *   if (error instanceof MMBatchValidationError) {
+   *     // HTTP 207 - Partial success with some batches failing due to validation errors
+   *     // HTTP 500 - A specific type representing complete failure due to validation issues;
+   *     //            other 500 types represent failure due to other issues and are not converted to MMBatchValidationError
+   *     // Note: Each batch error contains ALL entities from the failing batch, not necessarily just the failed ones
+   *
+   *     console.log(`⚠️  Batch processing completed with errors (HTTP ${error.httpStatus})`);
+   *     console.log(`📊 Metrics: ${error.upsertedEntities} upserted, ${error.localDedupeCount} locally deduplicated, ${error.apiDedupeCount} API deduplicated`);
+   *     console.log(`❌ Error count: ${error.errorCount}`);
+   *
+   *     // Process specific batch errors for retry or logging
+   *     error.batchErrors.forEach((batchError, index) => {
+   *       console.log(`Batch ${index + 1} error: ${batchError.message}`);
+   *       console.log(`All entities in failing batch:`, batchError.affectedEntities);
+   *
+   *       // Example: Queue entire failing batch for retry (contains both successful and failed entities)
+   *       await queueForRetry(batchError.affectedEntities);
+   *     });
+   *
+   *     // Decide whether to continue or halt based on httpStatus
+   *     if (error.httpStatus === 207) {
+   *       // Partial success - some batches processed successfully, others failed
+   *       console.log('⚠️  Continuing with partial success');
+   *     } else if (error.httpStatus === 500) {
+   *       // Complete failure - all batches failed due to validation issues
+   *       console.log('🛑 Complete failure - no records processed');
+   *       throw error; // Re-throw if complete failure should halt the process
+   *     }
+   *
+   *   } else {
+   *     // Other underlying errors (network issues, authentication, etc.)
+   *     console.error('🚨 Unexpected error during MM API call:', error);
+   *
+   *     // Example: Check for specific error types
+   *     if (error.message?.includes('authentication')) {
+   *       console.error('🔐 Authentication issue - check MM API credentials');
+   *     } else if (error.message?.includes('network') || error.code === 'ECONNREFUSED') {
+   *       console.error('🌐 Network connectivity issue - check MM API endpoint');
+   *     }
+   *
+   *     throw error; // Re-throw for upstream handling
+   *   }
+   * }
+   * ```
+   *
+   * @param entityType The type of entity being processed
+   * @param mmRecords The records to process
+   * @param batchCacheManager The batch cache manager instance; pass in null if caching is not desired
+   *
+   * @returns WriteEntitiesToMMResult on complete success (HTTP 200)
+   * @throws MMBatchValidationError on partial success (HTTP 207) or complete failure (HTTP 500) with structured error details
+   * @throws Error on other underlying issues (network, authentication, etc.)
+   */
+  static async writeEntitiesToMM(entityType, mmRecords, batchCacheManager) {
+    return MMEntityProcessor.writeEntities(
+      entityType,
+      mmRecords,
+      batchCacheManager
+    );
+  }
+  /**
+   * Writes a batch of Work Order related entities to MM maintaining referential integrity by:
+   * 1. Processing parts first (base entities)
+   * 2. Processing part operations (depends on parts)
+   * 3. Processing work orders (depends on parts)
+   * 4. Processing work order operations (depends on work orders and part operations)
+   *
+   * This ensures all foreign key constraints are satisfied and prevents referential integrity errors.
+   *
+   * @param workOrderBatch The batch containing all related entities
+   * @param batchCacheManager The batch cache manager instance; pass in null if caching is not desired
+   *
+   * @returns Combined results from all entity processing
+   * @throws MMBatchValidationError on partial success or complete failure with structured error details
+   * @throws Error on other underlying issues (network, authentication, etc.)
+   */
+  static async writeWorkOrderBatchToMM(workOrderBatch, batchCacheManager) {
+    const partsResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.PARTS,
+      workOrderBatch.parts,
+      batchCacheManager
+    );
+    const partOperationsResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.PART_OPERATION,
+      workOrderBatch.partOperations,
+      batchCacheManager
+    );
+    const workOrdersResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.WORK_ORDERS,
+      workOrderBatch.workOrders,
+      batchCacheManager
+    );
+    const workOrderOperationsResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.WORK_ORDER_OPERATIONS,
+      workOrderBatch.workOrderOperations,
+      batchCacheManager
+    );
+    return {
+      parts: partsResult,
+      partOperations: partOperationsResult,
+      workOrders: workOrdersResult,
+      workOrderOperations: workOrderOperationsResult
+    };
+  }
+  /**
+   * Processes flattened work order data and syncs it to MM maintaining referential integrity.
+   *
+   * This method expects flattened data where each row contains both work order and operation information
+   * with camelCase field names matching the GraphQL schema. It will automatically extract and deduplicate
+   * parts, part operations, work orders, and work order operations, then process them in the correct order
+   * to maintain referential integrity.
+   *
+   * @param flattenedData Array of flattened rows containing both work order and operation data (camelCase fields)
+   * @param batchCacheManager The batch cache manager instance; pass in null if caching is not desired
+   *
+   * @returns Combined results from all entity processing with detailed logging information
+   * @throws MMBatchValidationError on partial success or complete failure with structured error details
+   * @throws Error on other underlying issues (network, authentication, etc.)
+   */
+  static async syncWorkOrderBatchFromFlattened(flattenedData, batchCacheManager) {
+    if (!flattenedData || flattenedData.length === 0) {
+      throw new Error("No flattened work order data provided");
+    }
+    const uniqueParts = /* @__PURE__ */ new Map();
+    const uniquePartOperations = /* @__PURE__ */ new Map();
+    const uniqueWorkOrders = /* @__PURE__ */ new Map();
+    const workOrderOperations = [];
+    for (const row of flattenedData) {
+      const partKey = `${row.partNumber}|${row.partRevision}|${row.method}`;
+      if (!uniqueParts.has(partKey)) {
+        uniqueParts.set(partKey, {
+          partNumber: row.partNumber,
+          // → partNumber
+          partRevision: row.partRevision,
+          // → partRevision
+          method: row.method
+          // → method
+        });
+      }
+      const partOpKey = `${row.partNumber}|${row.partRevision}|${row.method}|${row.sequenceNumber}`;
+      if (!uniquePartOperations.has(partOpKey)) {
+        uniquePartOperations.set(partOpKey, {
+          partNumber: row.partNumber,
+          // → partNumber
+          partRevision: row.partRevision,
+          // → partRevision
+          method: row.method,
+          // → method
+          sequenceNumber: row.sequenceNumber,
+          // → sequenceNumber
+          resourceId: row.resourceId,
+          // → resourceId
+          cycleTimeMs: row.cycleTimeMs,
+          // → cycleTimeMs
+          setupTimeMs: row.setupTimeMs,
+          // → setupTimeMs
+          description: row.operationDescription || "",
+          // → description
+          quantityPerPart: row.quantityPerPart || 1
+          // → quantityPerPart
+        });
+      }
+      const workOrderKey = row.workOrderId;
+      if (!uniqueWorkOrders.has(workOrderKey)) {
+        uniqueWorkOrders.set(workOrderKey, {
+          workOrderId: row.workOrderId,
+          // → workOrderId
+          lot: row.lot,
+          // → lot
+          split: row.split,
+          // → split
+          sub: row.sub,
+          // → sub
+          status: row.status,
+          // → status
+          dueDate: row.dueDate,
+          // → dueDate
+          description: row.description,
+          // → description
+          scheduledStartDate: row.scheduledStartDate,
+          // → scheduledStartDate
+          scheduledEndDate: row.scheduledEndDate,
+          // → scheduledEndDate
+          closedDate: row.closedDate,
+          // → closedDate
+          quantityRequired: row.quantityRequired,
+          // → quantityRequired
+          partNumber: row.partNumber,
+          // → partNumber
+          partRevision: row.partRevision,
+          // → partRevision
+          method: row.method
+          // → method
+        });
+      }
+      workOrderOperations.push({
+        workOrderId: row.workOrderId,
+        // → workOrderId
+        lot: row.lot,
+        // → lot
+        split: row.split,
+        // → split
+        sub: row.sub,
+        // → sub
+        sequenceNumber: row.sequenceNumber,
+        // → sequenceNumber
+        resourceId: row.resourceId,
+        // → resourceId
+        startQuantity: row.startQuantity,
+        // → startQuantity
+        finishQuantity: row.finishQuantity,
+        // → finishQuantity
+        expectedRejectRate: row.expectedRejectRate,
+        // → expectedRejectRate
+        scheduledStartDate: row.opScheduledStartDate,
+        // → scheduledStartDate
+        scheduledFinishDate: row.opScheduledFinishDate,
+        // → scheduledFinishDate
+        closedDate: row.opClosedDate,
+        // → closedDate
+        cycleTimeMs: row.cycleTimeMs,
+        // → cycleTimeMs
+        setupTimeMs: row.setupTimeMs,
+        // → setupTimeMs
+        productionburdenRateHourly: row.productionburdenRateHourly,
+        // → productionburdenRateHourly
+        setupburdenRatehourly: row.setupburdenRatehourly,
+        // → setupburdenRatehourly
+        operationType: row.operationType,
+        // → operationType
+        quantityPerPart: row.quantityPerPart,
+        // → quantityPerPart
+        status: row.opStatus || row.status
+        // → status
+      });
+    }
+    const parts = Array.from(uniqueParts.values()).map(
+      (item) => new MMSendPart(
+        item.partNumber || "",
+        // partNumber
+        item.partRevision || "",
+        // partRevision
+        item.method || "Standard"
+        // method
+      )
+    );
+    const partOperations = Array.from(uniquePartOperations.values()).map(
+      (item) => new MMSendPartOperation(
+        item.partNumber || "",
+        // partNumber
+        item.partRevision || "",
+        // partRevision
+        item.method || "Standard",
+        // method
+        item.sequenceNumber?.toString() || "",
+        // sequenceNumber
+        item.resourceId?.toString() || "",
+        // resourceId
+        item.cycleTimeMs || 0,
+        // cycleTimeMs
+        item.setupTimeMs || 0,
+        // setupTimeMs
+        item.description || "",
+        // description
+        item.quantityPerPart || 1
+        // quantityPerPart
+      )
+    );
+    const transformedWorkOrders = Array.from(uniqueWorkOrders.values()).map(
+      (item) => new MMSendWorkOrder(
+        item.workOrderId?.toString() || "",
+        // workOrderId
+        item.lot || "",
+        // lot
+        item.split || "",
+        // split
+        item.sub || "",
+        // sub
+        item.status || "Open",
+        // status
+        item.dueDate ? new Date(item.dueDate).toISOString() : null,
+        // dueDate
+        item.description || "",
+        // description
+        item.scheduledStartDate ? new Date(item.scheduledStartDate).toISOString() : null,
+        // scheduledStartDate
+        item.scheduledEndDate ? new Date(item.scheduledEndDate).toISOString() : null,
+        // scheduledEndDate
+        item.closedDate ? new Date(item.closedDate).toISOString() : null,
+        // closedDate
+        item.quantityRequired || 0,
+        // quantityRequired
+        item.partNumber || "",
+        // partNumber
+        item.partRevision || "",
+        // partRevision
+        item.method || "Standard"
+        // method
+      )
+    );
+    const transformedWorkOrderOperations = workOrderOperations.map(
+      (item) => new MMSendWorkOrderOperation(
+        item.workOrderId?.toString() || "",
+        // workOrderId
+        item.lot || "",
+        // lot
+        item.split || "",
+        // split
+        item.sub || "",
+        // sub
+        item.sequenceNumber?.toString() || "",
+        // sequenceNumber
+        item.resourceId?.toString() || "",
+        // resourceId
+        item.startQuantity || 0,
+        // startQuantity
+        item.finishQuantity || 0,
+        // finishQuantity
+        item.expectedRejectRate || 0,
+        // expectedRejectRate
+        item.scheduledStartDate ? new Date(item.scheduledStartDate).toISOString() : null,
+        // scheduledStartDate
+        item.scheduledFinishDate ? new Date(item.scheduledFinishDate).toISOString() : null,
+        // scheduledFinishDate
+        item.closedDate ? new Date(item.closedDate).toISOString() : null,
+        // closedDate
+        item.cycleTimeMs || 0,
+        // cycleTimeMs
+        item.setupTimeMs || 0,
+        // setupTimeMs
+        parseFloat(item.productionburdenRateHourly || "0"),
+        // productionburdenRateHourly
+        parseFloat(item.setupburdenRatehourly || "0"),
+        // setupburdenRatehourly
+        item.operationType || "Production",
+        // operationType
+        item.quantityPerPart || 1,
+        // quantityPerPart
+        item.status || "Open"
+        // status
+      )
+    );
+    const partsResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.PARTS,
+      parts,
+      batchCacheManager
+    );
+    const partOperationsResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.PART_OPERATION,
+      partOperations,
+      batchCacheManager
+    );
+    const workOrdersResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.WORK_ORDERS,
+      transformedWorkOrders,
+      batchCacheManager
+    );
+    const workOrderOperationsResult = await MMEntityProcessor.writeEntities(
+      ERPObjType.WORK_ORDER_OPERATIONS,
+      transformedWorkOrderOperations,
+      batchCacheManager
+    );
+    return {
+      parts: partsResult,
+      partOperations: partOperationsResult,
+      workOrders: workOrdersResult,
+      workOrderOperations: workOrderOperationsResult
+    };
+  }
+}
+const DEFAULT_RETRY_ATTEMPTS$1 = 0;
+const DEFAULT_PAGINATION_LIMIT = 100;
+class RestAPIService {
+  client;
+  config;
+  paginationLimit;
+  constructor(config2, retryAttempts, paginationLimit) {
+    this.config = config2;
+    this.paginationLimit = paginationLimit ?? DEFAULT_PAGINATION_LIMIT;
+    this.client = HTTPClientFactory.getInstance({
+      baseUrl: config2.apiUrl,
+      retryAttempts: retryAttempts ?? DEFAULT_RETRY_ATTEMPTS$1
+    });
+  }
+  //#region Get Request Helpers
+  async getHeaders() {
+    const token = await this.config.getAuthToken();
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    };
+  }
+  buildQueryParams(query = {}) {
+    const { limit, nextPage, filter } = query;
+    const queryParams = {};
+    if (limit) {
+      queryParams.take = limit.toString();
+    }
+    if (nextPage) {
+      queryParams.skip = nextPage;
+    }
+    if (filter) {
+      if (filter.in) {
+        filter.in.forEach((filterIn) => {
+          const query2 = filterIn.value.join("|");
+          queryParams[`${filterIn.field}[in]`] = query2;
+        });
+      }
+      if (filter.and) {
+        queryParams["filter[and]"] = buildLogicalCondition(filter.and, "and");
+      }
+      if (filter.or) {
+        queryParams["filter[or]"] = buildLogicalCondition(filter.or, "or");
+      }
+    }
+    return new URLSearchParams(queryParams);
+  }
+  /**
+   * Builds pagination metadata for API responses
+   * @param limit - Optional limit for this specific request. If not provided, uses the service's default pagination limit
+   * @param nextPage - Optional next page token
+   * @param previousPage - Optional previous page token
+   * @param dataLength - Number of items in the current response
+   * @param totalCount - Total number of items available
+   * @returns Pagination metadata including count, limit, and page tokens
+   */
+  buildPagination(limit, nextPage, previousPage, dataLength = 0, totalCount) {
+    const paging = {
+      count: totalCount || 0,
+      limit: limit || this.paginationLimit,
+      nextPage: void 0,
+      previousPage
+    };
+    if (limit) {
+      paging.limit = limit;
+      const currentSkip = parseInt(nextPage || "0");
+      if (dataLength > 0 && (!totalCount || currentSkip + limit < totalCount)) {
+        paging.nextPage = `${currentSkip + limit}`;
+      }
+    }
+    return paging;
+  }
+  buildUrl(endpoint, queryParams) {
+    const pathParts = [this.config.apiUrl || ""];
+    pathParts.push(endpoint);
+    const path2 = pathParts.filter(Boolean).join("/");
+    return queryParams ? `${path2}?${queryParams.toString()}` : path2;
+  }
+  //#endregion get request helpers
+  async get(endpoint, query = {}) {
+    try {
+      const params = this.buildQueryParams(query);
+      const url = this.buildUrl(endpoint, params);
+      const headers = await this.getHeaders();
+      const response = await this.client.request({
+        method: "GET",
+        url,
+        headers
+      });
+      const paging = this.buildPagination(
+        query.limit,
+        query.nextPage,
+        query.previousPage,
+        response.data.Data?.length,
+        response.data.TotalCount
+      );
+      return {
+        data: response.data.Data || [],
+        metadata: {
+          pagination: paging
+        }
+      };
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  async patch(endpoint, id, data) {
+    try {
+      const url = this.buildUrl(`${endpoint}/${id}`);
+      const headers = await this.getHeaders();
+      const response = await this.client.request({
+        method: "PATCH",
+        url,
+        data,
+        headers
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  async post(endpoint, data) {
+    try {
+      const url = this.buildUrl(endpoint);
+      const headers = await this.getHeaders();
+      const response = await this.client.request({
+        method: "POST",
+        url,
+        data,
+        headers
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * Cleanup all HTTP connections and resources
+   * Call this when the service is no longer needed
+   */
+  async destroy() {
+    await this.client.destroy();
+  }
+}
+function getERPAPITypeFromEntity(entity, entityMap) {
+  const entry = Object.entries(entityMap).find(
+    ([_, value]) => value.entity === entity
+  );
+  return entry ? Number(entry[0]) : void 0;
+}
+const isNonEmptyString = (v) => typeof v === "string" && v.trim().length > 0;
+function getErrorType(error) {
+  if (error && typeof error === "object") {
+    const o = error;
+    if (isNonEmptyString(o.code)) return o.code;
+    if (isNonEmptyString(o.name)) return o.name;
+    const ctorName = o.constructor?.name;
+    if (isNonEmptyString(ctorName) && ctorName !== "Object") return ctorName;
+  }
+  return "Error";
+}
+function formatError(error) {
+  if (!error) {
+    return {
+      message: "Unknown error occurred",
+      code: "UNKNOWN_ERROR"
+    };
+  }
+  if (error.isAxiosError || error.name === "AxiosError") {
+    return formatAxiosError(error);
+  }
+  if (error.message && error.code && typeof error.message === "string" && typeof error.code === "string" && !error.config) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message || "An error occurred",
+      code: "ERROR",
+      metadata: {
+        name: error.name
+      }
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      message: error,
+      code: "ERROR"
+    };
+  }
+  const message = error.message || error.toString?.() || "Unknown error occurred";
+  return {
+    message: typeof message === "string" ? message : JSON.stringify(message),
+    code: error.code || "UNKNOWN_ERROR"
+  };
+}
+function formatAxiosError(error) {
+  const httpStatus = error.response?.status;
+  const method = error.config?.method?.toUpperCase();
+  const url = error.config?.url;
+  let message = error._extractedMessage;
+  if (!message) {
+    const extractedMessage = extractErrorMessage(error.response?.data);
+    message = extractedMessage || error.response?.statusText || error.message || "Request failed";
+  }
+  const code = categorizeHttpError(httpStatus);
+  const metadata = {
+    method,
+    url
+  };
+  if (httpStatus === 401 || httpStatus === 403) {
+    metadata.hint = "Check authentication credentials";
+  } else if (httpStatus === 404) {
+    metadata.hint = "Resource not found - check endpoint URL";
+  } else if (httpStatus && httpStatus >= 500) {
+    metadata.hint = "ERP system may be temporarily unavailable";
+  }
+  return {
+    message,
+    code,
+    httpStatus,
+    metadata
+  };
+}
+function extractErrorMessage(data) {
+  if (!data) return null;
+  const possibleFields = [
+    "ErrorMessage",
+    // Epicor
+    "error.message",
+    // Common REST format
+    "error",
+    // Simple format
+    "Message",
+    // .NET style
+    "message",
+    // JavaScript style
+    "errorMessage",
+    // Camel case
+    "error_message",
+    // Snake case
+    "errors[0].message",
+    // Array of errors
+    "title",
+    // Problem details format
+    "detail"
+    // Problem details format
+  ];
+  for (const field of possibleFields) {
+    const value = getNestedValue(data, field);
+    if (value && typeof value === "string") {
+      return value;
+    }
+  }
+  if (typeof data === "string") {
+    try {
+      const parsed = JSON.parse(data);
+      return extractErrorMessage(parsed);
+    } catch {
+      return data;
+    }
+  }
+  return null;
+}
+function getNestedValue(obj, path2) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (const part of parts) {
+    const arrayMatch = part.match(/(\w+)\[(\d+)\]/);
+    if (arrayMatch) {
+      const [, key, index2] = arrayMatch;
+      current = current?.[key]?.[parseInt(index2, 10)];
+    } else {
+      current = current?.[part];
+    }
+    if (current === void 0 || current === null) {
+      return null;
+    }
+  }
+  return current;
+}
+function categorizeHttpError(status) {
+  if (!status) return "NETWORK_ERROR";
+  if (status === 400) return "VALIDATION_ERROR";
+  if (status === 401) return "AUTHENTICATION_ERROR";
+  if (status === 403) return "AUTHORIZATION_ERROR";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "CONFLICT";
+  if (status === 422) return "VALIDATION_ERROR";
+  if (status === 429) return "RATE_LIMIT";
+  if (status >= 500) return "ERP_SERVER_ERROR";
+  if (status >= 400) return "CLIENT_ERROR";
+  return "HTTP_ERROR";
+}
+function formatErrorForLogging(error) {
+  const formatted = formatError(error);
+  let message = `[${formatted.code}] ${formatted.message}`;
+  if (formatted.httpStatus) {
+    message = `[${formatted.httpStatus}] ${message}`;
+  }
+  return message;
+}
+class LogEntry {
+  level;
+  message;
+  dedupeKey;
+  eventTime;
+  constructor(params) {
+    this.level = params.level;
+    this.message = params.message;
+    this.dedupeKey = params.dedupeKey;
+    this.eventTime = Date.now();
+  }
+}
+function isLogResponse(value) {
+  if (value === null || typeof value !== "object") return false;
+  const v = value;
+  if (typeof v.message !== "string") return false;
+  if ("processed" in v && typeof v.processed !== "number") return false;
+  return true;
+}
+class MMConnectorLogger {
+  MAX_MSG_LEN = 2e3;
+  mmApiClient;
+  deduper;
+  source;
+  constructor(source, deduper) {
+    if (source.length < 1 || source.length > 64) {
+      throw new Error("source must be 1-64 characters");
+    }
+    this.mmApiClient = new MMApiClient();
+    this.deduper = deduper;
+    this.source = source;
+  }
+  // Deduplication helpers are delegated to injected FileLogDeduper
+  /**
+   * Send a single log entry to the MM cloud with deduplication.
+   * 
+   * The deduplication is handled by the injected LogDeduper.
+   * If no deduper is injected, the log entry is sent without deduplication.
+   * 
+   * The standard deduper, FileLogDeduper, stores the deduplication state in a file, 
+   * allowing deduplication across jobs, 
+   * 
+   * @param logEntry - The log entry to send
+   * @returns Promise resolving to the API response or null if suppressed
+   * @throws HTTPError if the request fails or Error if the log entry is invalid
+   */
+  async sendLog(logEntry) {
+    this.validateLogEntry(logEntry);
+    const now = Date.now();
+    let messageToSend = logEntry.message;
+    if (this.deduper) {
+      const decision = await this.deduper.decide(logEntry, now);
+      if (decision === null) return null;
+      messageToSend = decision;
+    }
+    try {
+      const logEntryToSend = {
+        source: this.source,
+        level: logEntry.level,
+        message: messageToSend
+      };
+      const response = await this.mmApiClient.sendConnectorLog(logEntryToSend);
+      if (this.deduper) {
+        await this.deduper.onSuccess(logEntry, now);
+      }
+      if (!isLogResponse(response)) {
+        logger.warn("Unexpected success response format from MM API for connector log", { response });
+        return { message: "Unexpected success response format when sending log" };
+      }
+      return { message: response.message };
+    } catch (error) {
+      logger.error("Failed to send log to MM cloud", {
+        level: logEntry.level,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  /**
+   * @throws Error if validation fails
+   */
+  validateLogEntry(logEntry) {
+    const allowedLevels = ["info", "warn", "error"];
+    if (!logEntry.level || !allowedLevels.includes(logEntry.level)) {
+      throw new Error(`level must be one of: ${allowedLevels.join(", ")}`);
+    }
+    if (!logEntry.message || typeof logEntry.message !== "string") {
+      throw new Error("message is required and must be a string");
+    }
+    logEntry.message = logEntry.message.slice(0, this.MAX_MSG_LEN);
+    if (!logEntry.dedupeKey || typeof logEntry.dedupeKey !== "string") {
+      throw new Error("dedupeKey is required and must be a string");
+    }
+    if (logEntry.dedupeKey.trim().length < 1) {
+      throw new Error("dedupeKey must be a non-empty string");
+    }
+  }
+  /**
+   * Retry all failed transmissions silently
+   * This method attempts to retry all messages that failed to transmit
+   * and removes them from the failed list if successful, else leaves them for the client to retry
+   * 
+   * Expected usage is by a client to call this as part of its own retry mechanism
+   */
+  async retryFailedTransmissions() {
+    if (!this.deduper || !this.deduper.retryFailedTransmissions) {
+      return;
+    }
+    await this.deduper.retryFailedTransmissions(async (entry, message) => {
+      await this.mmApiClient.sendConnectorLog({
+        source: this.source,
+        level: entry.level,
+        message
+      });
+    });
+  }
+  /**
+   * Clean up resources
+   */
+  async destroy() {
+    await this.mmApiClient.destroy();
+  }
+}
+class FileLogDeduper {
+  storeFilePath;
+  windowMs;
+  ttlMs;
+  sweepIntervalMs;
+  lastSweepTsMs;
+  DEFAULT_WINDOW_TEN_MINS = 600;
+  DEFAULT_TTL_ONE_HOUR = 3600;
+  DEFAULT_SWEEP_INTERVAL_FIVE_MINS = 300;
+  DEFAULT_STORE_FILE_PATH = path.join("/tmp", "log-deduplication.json");
+  /**
+   * Ctor.
+   * @param storeFilePath:         The path to the file where the deduplication store is stored; recommended is to use the default
+   * @param windowSeconds:         Suppression window. Duplicates within this period are suppressed.
+   * @param ttlSeconds:            Eviction TTL. Store entries for keys inactive beyond this are removed. Enforced to be ≥ windowSeconds.
+   * @param sweepIntervalSeconds:  Efficiency parameter. How often (min interval) to run opportunistic eviction; retry always sweeps
+   *                               The sweep is lazy, used only when the store is accessed
+   */
+  constructor({
+    storeFilePath = this.DEFAULT_STORE_FILE_PATH,
+    windowSeconds = this.DEFAULT_WINDOW_TEN_MINS,
+    ttlSeconds = this.DEFAULT_TTL_ONE_HOUR,
+    sweepIntervalSeconds = this.DEFAULT_SWEEP_INTERVAL_FIVE_MINS
+  } = {}) {
+    this.storeFilePath = storeFilePath;
+    this.windowMs = Math.max(1, windowSeconds) * 1e3;
+    this.ttlMs = Math.max(this.windowMs, Math.max(1, ttlSeconds) * 1e3);
+    this.sweepIntervalMs = Math.max(1, sweepIntervalSeconds) * 1e3;
+    this.lastSweepTsMs = 0;
+    this.ensureStoreFileExists();
+  }
+  /** 
+   * Deduplication gating function
+   * Returns the formatted message to send, or null to suppress
+   * Decision is based on the dedupeKey and the time of the entry
+  */
+  async decide(entry, now) {
+    if (!entry.dedupeKey || typeof entry.dedupeKey !== "string" || entry.dedupeKey.trim().length === 0) {
+      throw new Error("dedupeKey is required and must be a non-empty string");
+    }
+    const key = entry.dedupeKey;
+    return this.withLock(async () => {
+      const store = this.readStore();
+      if (now - this.lastSweepTsMs >= this.sweepIntervalMs) {
+        this.evictExpiredInStore(store, now);
+        this.lastSweepTsMs = now;
+        this.writeStore(store);
+      }
+      const existing = store[key];
+      if (existing) {
+        const withinWindow = existing.lastTransmitted > 0 && existing.lastTransmitted + this.windowMs > now;
+        if (withinWindow) {
+          store[key] = {
+            ...existing,
+            suppressedCount: existing.suppressedCount + 1,
+            firstUnsentEventTs: existing.suppressedCount === 0 ? entry.eventTime ?? now : existing.firstUnsentEventTs,
+            lastEventTs: entry.eventTime ?? now,
+            level: entry.level,
+            message: entry.message
+          };
+          this.writeStore(store);
+          return null;
+        }
+        const messageToSend2 = this.formatMessage(entry.message, entry.eventTime ?? now, existing.suppressedCount, existing.firstUnsentEventTs);
+        store[key] = {
+          ...existing,
+          suppressedCount: 0,
+          firstUnsentEventTs: 0,
+          lastEventTs: entry.eventTime ?? now,
+          level: entry.level,
+          message: entry.message
+        };
+        this.writeStore(store);
+        return messageToSend2;
+      }
+      const messageToSend = this.formatMessage(entry.message, entry.eventTime ?? now, 0);
+      store[key] = {
+        lastTransmitted: 0,
+        suppressedCount: 0,
+        firstUnsentEventTs: entry.eventTime ?? now,
+        lastEventTs: entry.eventTime ?? now,
+        level: entry.level,
+        message: entry.message
+      };
+      this.writeStore(store);
+      return messageToSend;
+    });
+  }
+  async onSuccess(entry, now) {
+    if (!entry.dedupeKey || typeof entry.dedupeKey !== "string" || entry.dedupeKey.trim().length === 0) {
+      throw new Error("dedupeKey is required and must be a non-empty string");
+    }
+    const key = entry.dedupeKey;
+    await this.withLock(async () => {
+      const store = this.readStore();
+      const existing = store[key];
+      if (existing) {
+        store[key] = {
+          ...existing,
+          lastTransmitted: now,
+          firstUnsentEventTs: 0,
+          suppressedCount: 0
+        };
+        this.writeStore(store);
+      }
+    });
+  }
+  async retryFailedTransmissions(send) {
+    const now = Date.now();
+    const entries = await this.withLock(async () => {
+      const store = this.readStore();
+      this.evictExpiredInStore(store, now);
+      this.lastSweepTsMs = now;
+      this.writeStore(store);
+      return Object.entries(store).filter(([, rec]) => rec.lastTransmitted === 0).map(([key, rec]) => ({ key, rec }));
+    });
+    for (const { key, rec } of entries) {
+      try {
+        const message = this.formatMessage(rec.message, rec.lastEventTs, rec.suppressedCount, rec.firstUnsentEventTs);
+        await send({ level: rec.level, message: rec.message, dedupeKey: key, eventTime: rec.lastEventTs }, message);
+        await this.withLock(async () => {
+          const store = this.readStore();
+          const current = store[key];
+          if (current) {
+            store[key] = {
+              ...current,
+              lastTransmitted: Date.now(),
+              suppressedCount: 0
+            };
+            this.writeStore(store);
+          }
+        });
+      } catch (err) {
+        logger.error("Failed to retry failed transmission", { key, rec, error: err });
+        return;
+      }
+    }
+  }
+  // --- Internals ---
+  ensureStoreFileExists() {
+    try {
+      if (!fs.existsSync(this.storeFilePath)) {
+        fs.writeFileSync(this.storeFilePath, JSON.stringify({}), "utf-8");
+      }
+    } catch {
+    }
+  }
+  readStore() {
+    try {
+      if (!fs.existsSync(this.storeFilePath)) return {};
+      const content = fs.readFileSync(this.storeFilePath, "utf-8");
+      return content ? JSON.parse(content) : {};
+    } catch {
+      return {};
+    }
+  }
+  writeStore(store) {
+    try {
+      fs.writeFileSync(this.storeFilePath, JSON.stringify(store, null, 2), "utf-8");
+    } catch {
+    }
+  }
+  formatMessage(message, eventTs, suppressedCount, firstUnsentEventTs) {
+    const timestamp = new Date(eventTs).toISOString();
+    const base = `${timestamp} | ${message}`;
+    if (suppressedCount > 0) {
+      const since = firstUnsentEventTs && firstUnsentEventTs > 0 ? ` since ${new Date(firstUnsentEventTs).toISOString()}` : "";
+      return `${base} (${suppressedCount} suppressed${since})`;
+    }
+    return base;
+  }
+  async withLock(fn) {
+    const lockPath = `${this.storeFilePath}.lock`;
+    const start = Date.now();
+    while (true) {
+      try {
+        const fd = fs.openSync(lockPath, "wx");
+        try {
+          const result = await fn();
+          return result;
+        } finally {
+          try {
+            fs.closeSync(fd);
+          } catch {
+          }
+          try {
+            fs.unlinkSync(lockPath);
+          } catch {
+          }
+        }
+      } catch {
+        if (Date.now() - start > 3e3) {
+          return await fn();
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+    }
+  }
+  /**
+   * Evict expired entries from the store based on the TTL and the key's last transmitted time
+   */
+  evictExpiredInStore(store, now) {
+    const keys = Object.keys(store);
+    if (keys.length === 0) return;
+    for (const key of keys) {
+      const rec = store[key];
+      const referenceTs = rec.lastTransmitted > 0 ? rec.lastTransmitted : rec.lastEventTs;
+      if (now - referenceTs > this.ttlMs) {
+        delete store[key];
+      }
+    }
+  }
+}
+class ApplicationInitializer {
+  /**
+   * Performs all necessary application initialization tasks
+   * This should be called before starting any services or jobs
+   */
+  static async initialize() {
+    try {
+      logger.info(
+        "\n================================INITIALIZING APPLICATION================================\n"
+      );
+      const coreConfig = CoreConfiguration.inst();
+      logger.info("Core Configuration loaded:", coreConfig.toSafeLogObject());
+      logger.info("Performing database startup checks...");
+      await SQLiteCoordinator.performStartupCheck();
+      logger.info("Database startup checks completed successfully");
+      logger.info("Running database migrations...");
+      await ApplicationInitializer.runMigrations();
+      logger.info("Database migrations completed successfully");
+      await getTimezoneOffsetAndPersist();
+      logger.info(
+        "\n================================APPLICATION INITIALIZATION COMPLETED================================\n"
+      );
+    } catch (error) {
+      logger.error("Critical initialization failure. Exiting.", error);
+      process.exitCode = 1;
+    }
+  }
+  /**
+   * Runs database migrations to ensure all required tables exist
+   */
+  static async runMigrations() {
+    const db = knex(config.local);
+    try {
+      await db.migrate.latest();
+    } catch (error) {
+      logger.error("Error running migrations:", error);
+      throw error;
+    } finally {
+      await db.destroy();
+    }
+  }
+}
+const DEFAULT_RETRY_ATTEMPTS = 0;
+class GraphQLService {
+  client;
+  config;
+  endpoint;
+  constructor(config2, endpoint, retryAttempts) {
+    this.config = config2;
+    this.endpoint = endpoint ? endpoint.startsWith("/") ? endpoint : `/${endpoint}` : "";
+    this.client = HTTPClientFactory.getInstance({
+      baseUrl: config2.apiUrl,
+      retryAttempts: retryAttempts ?? DEFAULT_RETRY_ATTEMPTS
+    });
+  }
+  async getHeaders() {
+    const token = await this.config.getAuthToken();
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    };
+  }
+  /**
+     * Handles a GraphQL response, properly handling both successful responses
+     * and GraphQL-level errors (which come in a 200 HTTP response)
+     * 
+     * From the GraphQL specification (https://spec.graphql.org/draft/#sec-Errors):
+  >  *     "When a GraphQL server encounters an error, it should return a response with a 
+  >  *      top-level "errors" field containing the error information. The response may still contain
+     *      a partial result in the "data" field if the error occurred after some data was already resolved."
+     * 
+     * And specifically about HTTP status codes:
+     *     "A server should return a 200 status code when a GraphQL operation successfully executes, including when  
+     *      the operation returns errors. A server should return a 400 status code when a GraphQL operation fails to execute."
+     */
+  handleGraphQLResponse(response) {
+    return {
+      data: response.data.data,
+      metadata: {
+        errors: response.data.errors,
+        extensions: response.data.extensions
+      }
+    };
+  }
+  /**
+   * Executes a GraphQL query
+   * @param query The GraphQL query string
+   * @param variables Optional variables for the query
+   * @returns The query result
+   * @throws {HTTPError} For HTTP/network errors only
+   */
+  async query(query, variables) {
+    try {
+      const headers = await this.getHeaders();
+      const response = await this.client.request({
+        method: "POST",
+        url: this.endpoint,
+        data: { query, variables },
+        headers
+      });
+      return this.handleGraphQLResponse(response);
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * Executes a GraphQL mutation
+   * @param mutation The GraphQL mutation string
+   * @param variables Optional variables for the mutation
+   * @returns The mutation result
+   * @throws {HTTPError} For HTTP/network errors only
+   */
+  async mutate(mutation, variables) {
+    try {
+      const headers = await this.getHeaders();
+      const response = await this.client.request({
+        method: "POST",
+        url: this.endpoint,
+        data: { query: mutation, variables },
+        headers
+      });
+      return this.handleGraphQLResponse(response);
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * Cleanup all HTTP connections and resources
+   * Call this when the service is no longer needed
+   */
+  async destroy() {
+    await this.client.destroy();
+  }
+}
+class OAuthClient {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Requests an OAuth token using the client credentials flow.
+   * The request is sent as application/x-www-form-urlencoded.
+   * @returns A promise that resolves to the token response containing access_token and expires_in
+   * @throws Error if the token request fails
+   */
+  async getToken() {
+    const formData = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this.config.clientId,
+      client_secret: this.config.clientSecret,
+      scope: this.config.scope
+    });
+    const response = await fetch(this.config.authUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      throw new Error(`OAuth token request failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.token_type !== "Bearer") {
+      throw new Error(`Unexpected token type: ${data.token_type}`);
+    }
+    return data;
+  }
+}
+const sc = StringCodec();
+class NatsService {
+  connection = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  config;
+  handlers = [];
+  statusPublishTimer = null;
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Register a handler for a specific subject pattern
+   */
+  registerHandler(registration) {
+    logger.info("Registering NATS handler", {
+      subject: registration.subject,
+      description: registration.description
+    });
+    this.handlers.push(registration);
+  }
+  /**
+   * Connect to NATS and start all registered handlers
+   */
+  async connect() {
+    if (!this.config.enabled) {
+      logger.info("NATS is disabled, skipping connection");
+      return;
+    }
+    try {
+      logger.info("Connecting to NATS...", {
+        servers: this.config.servers,
+        name: this.config.name
+      });
+      this.connection = await connect({
+        servers: this.config.servers,
+        name: this.config.name,
+        reconnect: this.config.reconnect ?? true,
+        maxReconnectAttempts: this.config.maxReconnectAttempts ?? -1,
+        reconnectTimeWait: this.config.reconnectTimeWait ?? 2e3
+      });
+      logger.info("Connected to NATS", {
+        server: this.connection.getServer(),
+        clientId: this.connection.info?.client_id
+      });
+      for (const registration of this.handlers) {
+        await this.startHandler(registration);
+      }
+      this.startStatusPublishing();
+      this.monitorConnection();
+      this.setupShutdown();
+    } catch (error) {
+      logger.error("Failed to connect to NATS", { error });
+      throw error;
+    }
+  }
+  /**
+   * Start a single handler (subscribe to its subject)
+   */
+  async startHandler(registration) {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+    const sub = this.connection.subscribe(registration.subject);
+    this.subscriptions.set(registration.subject, sub);
+    logger.info("Started NATS handler", {
+      subject: registration.subject,
+      description: registration.description
+    });
+    (async () => {
+      for await (const msg of sub) {
+        try {
+          const data = sc.decode(msg.data);
+          logger.info("Received NATS message", {
+            subject: msg.subject,
+            hasReply: !!msg.reply
+          });
+          let parsedData;
+          try {
+            parsedData = JSON.parse(data);
+          } catch {
+            parsedData = data;
+          }
+          const response = await registration.handler.handle(parsedData, msg.subject);
+          if (msg.reply && response !== void 0) {
+            const responseStr = JSON.stringify(response);
+            msg.respond(sc.encode(responseStr));
+            logger.info("Sent reply", { replySubject: msg.reply });
+          }
+        } catch (error) {
+          logger.error("Error handling NATS message", {
+            subject: msg.subject,
+            error
+          });
+          if (msg.reply) {
+            const errorResponse = {
+              status: "error",
+              error: {
+                message: error instanceof Error ? error.message : "Unknown error",
+                code: "HANDLER_ERROR"
+              }
+            };
+            msg.respond(sc.encode(JSON.stringify(errorResponse)));
+          }
+        }
+      }
+    })();
+  }
+  /**
+   * Publish a message to a subject (for pub/sub)
+   */
+  async publish(subject, data) {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    this.connection.publish(subject, sc.encode(message));
+    logger.info("Published NATS message", { subject });
+  }
+  /**
+   * Send a request and wait for reply (for request-reply)
+   */
+  async request(subject, data, timeoutMs = 3e4) {
+    if (!this.connection) {
+      throw new Error("NATS connection not established");
+    }
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const response = await this.connection.request(
+      subject,
+      sc.encode(message),
+      { timeout: timeoutMs }
+    );
+    const responseData = sc.decode(response.data);
+    try {
+      return JSON.parse(responseData);
+    } catch {
+      return responseData;
+    }
+  }
+  /**
+   * Check if connected to NATS
+   */
+  isConnected() {
+    return this.connection !== null && !this.connection.isClosed();
+  }
+  /**
+   * Start automatic status publishing (every 30 seconds)
+   */
+  startStatusPublishing() {
+    logger.info("Starting status publishing (every 30 seconds)");
+    this.publishStatus();
+    this.statusPublishTimer = setInterval(() => {
+      this.publishStatus();
+    }, 3e4);
+  }
+  /**
+   * Publish connector status
+   */
+  async publishStatus() {
+    try {
+      const status = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        locationRef: this.config.locationRef,
+        erpType: this.config.erpType,
+        natsConnected: this.isConnected()
+      };
+      await this.publish(
+        `mm.14.${this.config.locationRef}.erp.status`,
+        status
+      );
+      logger.debug("Published connector status");
+    } catch (error) {
+      logger.error("Failed to publish status", { error });
+    }
+  }
+  /**
+   * Monitor connection status
+   */
+  monitorConnection() {
+    if (!this.connection) return;
+    (async () => {
+      for await (const status of this.connection.status()) {
+        if (status.type !== "pingTimer") {
+          logger.info("NATS connection status", {
+            type: status.type,
+            data: status.data
+          });
+        }
+      }
+    })();
+  }
+  /**
+   * Setup graceful shutdown
+   */
+  setupShutdown() {
+    const shutdown = async () => {
+      logger.info("Shutting down NATS service...");
+      await this.disconnect();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+  /**
+   * Disconnect from NATS
+   */
+  async disconnect() {
+    if (this.statusPublishTimer) {
+      clearInterval(this.statusPublishTimer);
+      this.statusPublishTimer = null;
+    }
+    if (this.connection) {
+      await this.connection.drain();
+      this.connection = null;
+      this.subscriptions.clear();
+      logger.info("Disconnected from NATS");
+    }
+  }
+  /**
+   * Get the location reference
+   */
+  getLocationRef() {
+    return this.config.locationRef;
+  }
+}
+class NatsLaborTicketListener {
+  connector;
+  natsService;
+  constructor(connector) {
+    this.connector = connector;
+  }
+  /**
+   * Start listening for labor ticket events via NATS
+   */
+  async start() {
+    try {
+      const companyInfo = await getCompanyInfo();
+      const erpType = this.connector.type || "unknown";
+      logger.info("Starting NATS listener for labor tickets", {
+        locationRef: companyInfo.locationRef,
+        companyId: companyInfo.companyId,
+        erpType,
+        servers: process.env.NATS_SERVERS || "nats://localhost:4222"
+      });
+      this.natsService = new NatsService({
+        servers: process.env.NATS_SERVERS || "nats://localhost:4222",
+        name: `${erpType}-connector`,
+        locationRef: companyInfo.locationRef,
+        erpType,
+        enabled: true,
+        reconnect: true,
+        maxReconnectAttempts: -1,
+        reconnectTimeWait: 2e3
+      });
+      this.registerHealthCheckHandler(companyInfo.locationRef, erpType);
+      this.registerLaborTicketHandler(companyInfo.locationRef, erpType);
+      await this.natsService.connect();
+      logger.info("NATS listener started successfully", {
+        subject: `mm.14.${companyInfo.locationRef}.labor-ticket.*`
+      });
+    } catch (error) {
+      logger.error("Failed to start NATS listener", { error });
+    }
+  }
+  /**
+   * Register health check handler - responds immediately to let Dashboard know connector is online
+   */
+  registerHealthCheckHandler(locationRef, erpType) {
+    if (!this.natsService) return;
+    this.natsService.registerHandler({
+      subject: `mm.14.${locationRef}.erp.health`,
+      description: "Health check - responds immediately to indicate connector is online",
+      handler: {
+        handle: async () => {
+          logger.debug("Health check received, sending pong");
+          return {
+            status: "online",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            locationRef,
+            erpType
+          };
+        }
+      }
+    });
+  }
+  /**
+   * Register labor ticket processing handler
+   */
+  registerLaborTicketHandler(locationRef, erpType) {
+    if (!this.natsService) return;
+    this.natsService.registerHandler({
+      subject: `mm.14.${locationRef}.labor-ticket.*`,
+      description: "Process labor tickets in real-time from NATS",
+      handler: {
+        handle: async ({ data }, subject) => {
+          const action = subject.split(".").pop();
+          const { actionPayload } = data;
+          const startTime = Date.now();
+          const { laborTicketRef } = actionPayload;
+          logger.info("Received labor ticket via NATS", {
+            action,
+            requestId: data.requestId,
+            laborTicketRef
+          });
+          return await SQLiteCoordinator.executeWithLock("to-erp", async () => {
+            try {
+              let laborTicketData;
+              if (laborTicketRef) {
+                const mmApiClient = new MMApiClient();
+                const laborTicket = await mmApiClient.fetchLaborTicketByRef(laborTicketRef);
+                logger.info("Fetched labor ticket data from MM API", {
+                  laborTicketRef,
+                  laborTicketId: laborTicket.laborTicketId
+                });
+                laborTicketData = {
+                  ...laborTicket,
+                  ...actionPayload
+                };
+              } else {
+                logger.info("No laborTicketRef provided, using actionPayload directly", {
+                  requestId: data.requestId
+                });
+                laborTicketData = actionPayload;
+              }
+              const mergedLaborTicket = new MMReceiveLaborTicket(laborTicketData);
+              const result = await this.processLaborTicket(
+                mergedLaborTicket,
+                action || "unknown"
+              );
+              await this.updateCheckpoint(erpType, result);
+              return {
+                status: "success",
+                requestId: data.requestId,
+                action,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                processingTimeMs: Date.now() - startTime,
+                laborTicketRef: result.laborTicketRef,
+                laborTicket: result.laborTicket
+              };
+            } catch (error) {
+              const formattedError = error?._formatted || formatError(error);
+              logger.debug("Error details", {
+                hasFormatted: !!error?._formatted,
+                isAxiosError: error?.isAxiosError,
+                errorMessage: error?.message,
+                responseStatus: error?.response?.status,
+                responseData: error?.response?.data
+              });
+              logger.error("Error handling labor ticket from NATS", {
+                error: formattedError.message,
+                code: formattedError.code,
+                requestId: data.requestId,
+                laborTicketRef
+              });
+              return {
+                status: "error",
+                requestId: data.requestId,
+                action,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                processingTimeMs: Date.now() - startTime,
+                error: {
+                  message: formattedError.message,
+                  code: formattedError.code,
+                  httpStatus: formattedError.httpStatus,
+                  metadata: formattedError.metadata,
+                  laborTicketRef
+                }
+              };
+            }
+          });
+        }
+      }
+    });
+  }
+  /**
+   * Process labor ticket in ERP and then create MM entities with ERP ID attached
+   */
+  async processLaborTicket(laborTicket, action) {
+    const { MMEntityProcessor: MMEntityProcessor2 } = await Promise.resolve().then(() => mmEntityProcessor);
+    const { ERPObjType: ERPObjType2 } = await Promise.resolve().then(() => erpTypes);
+    const { MMSendLaborTicket: MMSendLaborTicket2 } = await Promise.resolve().then(() => index);
+    logger.info("Processing labor ticket: ERP first, then MM creation", {
+      laborTicketRef: laborTicket.laborTicketRef,
+      action,
+      hasLaborTicketId: !!laborTicket.laborTicketId
+    });
+    try {
+      let erpResult;
+      if (action === "create" || !laborTicket.laborTicketId) {
+        erpResult = await this.connector.createLaborTicketInERP(laborTicket);
+        logger.info("Successfully created labor ticket in ERP", {
+          laborTicketRef: laborTicket.laborTicketRef,
+          erpUid: erpResult.erpUid
+        });
+      } else {
+        erpResult = { laborTicket: await this.connector.updateLaborTicketInERP(laborTicket) };
+        logger.info("Successfully updated labor ticket in ERP", {
+          laborTicketRef: laborTicket.laborTicketRef
+        });
+      }
+      const laborTicketForMM = { ...laborTicket };
+      if (erpResult.erpUid) {
+        laborTicketForMM.laborTicketId = erpResult.erpUid;
+        if (!laborTicket.laborTicketId && laborTicketForMM.laborTicketRef) {
+          const mmApiClient = new MMApiClient();
+          await mmApiClient.updateLaborTicketIdByRef(
+            laborTicketForMM.laborTicketRef,
+            erpResult.erpUid
+          );
+          logger.info("Patched existing MM labor ticket with new ERP ID", {
+            laborTicketRef: laborTicketForMM.laborTicketRef,
+            laborTicketId: erpResult.erpUid
+          });
+        }
+      }
+      laborTicketForMM.state = laborTicketForMM.clockOut ? "CLOSED" : "OPEN";
+      const mmLaborTicket = MMSendLaborTicket2.fromPlainObject(laborTicketForMM);
+      const mmResult = await MMEntityProcessor2.writeEntities(
+        ERPObjType2.LABOR_TICKETS,
+        [mmLaborTicket],
+        null
+        // No caching for real-time operations
+      );
+      logger.info("Successfully updated MM entities after ERP operation", {
+        laborTicketRef: laborTicketForMM.laborTicketRef,
+        laborTicketId: laborTicketForMM.laborTicketId,
+        entitiesCreated: mmResult.upsertedEntities
+      });
+      return {
+        laborTicketRef: laborTicketForMM.laborTicketRef,
+        laborTicket: laborTicketForMM
+      };
+    } catch (error) {
+      const formattedError = formatError(error);
+      logger.error("Failed to process labor ticket with MM creation", {
+        laborTicketRef: laborTicket.laborTicketRef,
+        action,
+        error: formattedError.message,
+        code: formattedError.code
+      });
+      const enhancedError = error;
+      enhancedError._formatted = formattedError;
+      throw enhancedError;
+    }
+  }
+  /**
+   * Update checkpoint to prevent to-erp polling job from reprocessing this ticket
+   * Only updates if the new timestamp is later than the current checkpoint (prevents moving backwards)
+   */
+  async updateCheckpoint(erpType, result) {
+    const mmApiClient = new MMApiClient();
+    const currentCheckpoint = await mmApiClient.getCheckpoint({
+      system: erpType,
+      table: "labor_tickets",
+      checkpointType: "export",
+      checkpointValue: {
+        timestamp: ""
+      }
+    });
+    const currentTimestamp = currentCheckpoint?.timestamp;
+    const newTimestamp = result.laborTicket.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
+    if (!currentTimestamp || new Date(newTimestamp) > new Date(currentTimestamp)) {
+      await mmApiClient.saveCheckpoint({
+        system: erpType,
+        table: "labor_tickets",
+        checkpointType: "export",
+        checkpointValue: {
+          timestamp: newTimestamp
+        }
+      });
+      logger.debug("Updated export checkpoint after NATS processing", {
+        laborTicketRef: result.laborTicketRef,
+        previousCheckpoint: currentTimestamp,
+        newCheckpoint: newTimestamp
+      });
+    } else {
+      logger.debug("Skipped checkpoint update (timestamp not newer)", {
+        laborTicketRef: result.laborTicketRef,
+        currentCheckpoint: currentTimestamp,
+        ticketTimestamp: newTimestamp
+      });
+    }
+  }
+}
+const runDataSyncService = async (connectorPath) => {
+  const config2 = CoreConfiguration.inst();
+  try {
+    const connector = await createConnectorFromPath(connectorPath);
+    if (process.env.NATS_ENABLED === "true") {
+      const natsListener = new NatsLaborTicketListener(connector);
+      await natsListener.start();
+    }
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = fileURLToPath(currentFileUrl);
+    const sdkDistPath = path.dirname(currentFilePath);
+    const jobsPath = path.join(
+      sdkDistPath,
+      "services",
+      "data-sync-service",
+      "jobs"
+    );
+    const bree = new Bree({
+      root: jobsPath,
+      logger,
+      worker: {
+        env: {
+          CONNECTOR_PATH: connectorPath,
+          // Pass through all required environment variables
+          MM_MAPPING_SERVICE_URL: process.env.MM_MAPPING_SERVICE_URL,
+          MM_MAPPING_AUTH_SERVICE_URL: process.env.MM_MAPPING_AUTH_SERVICE_URL,
+          MM_MAPPING_SERVICE_TOKEN: process.env.MM_MAPPING_SERVICE_TOKEN,
+          ERP_SYSTEM: process.env.ERP_SYSTEM,
+          LOG_LEVEL: process.env.LOG_LEVEL,
+          NODE_ENV: process.env.NODE_ENV,
+          RETRY_ATTEMPTS: process.env.RETRY_ATTEMPTS,
+          CACHE_TTL: process.env.CACHE_TTL,
+          // Pass through all other environment variables that might be needed
+          ...process.env
+        }
+      },
+      jobs: [
+        // {
+        //   name: 'run-migrations',        // Running this once on startup will create the tables in the sqlite database
+        // },
+        {
+          name: "from-erp",
+          timeout: "10s",
+          interval: config2.fromErpInterval
+        },
+        {
+          name: "to-erp",
+          //timeout: '3s',                  // Use timeout during development to see the job in action quickly
+          interval: config2.toErpInterval
+        },
+        {
+          name: "retry-failed-labor-tickets",
+          interval: config2.retryLaborTicketsInterval
+        },
+        {
+          name: "clean-up-expired-cache",
+          interval: config2.cacheExpirationCheckInterval
+        }
+      ]
+    });
+    logger.info(
+      "\n================================INITIATING DATA SYNC CYCLES (Bree)================================\n"
+    );
+    const jobsConfig = bree.config.jobs.map((job) => ({
+      name: job.name,
+      interval: job.interval,
+      timeout: job.timeout
+    }));
+    logger.info("JOBS CONFIGURATION:", { jobs: jobsConfig });
+    const graceful = new Graceful({ brees: [bree] });
+    graceful.listen();
+    (async () => {
+      await bree.start();
+    })();
+    bree.on("jobStarted", (job) => {
+      console.log("Job " + job.name + " started");
+    });
+    bree.on("jobCompleted", (job) => {
+      if (job.error) {
+        console.error("Job " + job.name + " failed:", job.error);
+      } else {
+        console.log("Job " + job.name + " completed successfully!");
+      }
+    });
+    bree.on("error", (error) => {
+      console.error("Bree error:", error);
+    });
+    logger.info(
+      "\n================================DATA SYNC CYCLES INITIATION COMPLETED================================\n"
+    );
+  } catch (error) {
+    logger.error("startUp: Error initiating data sync cycles:", error);
+  }
+};
+const SQLServerConfigSchema = z.object({
+  user: z.string().nonempty("User is required."),
+  password: z.string().nonempty("Password is required."),
+  database: z.string().nonempty("Database name is required."),
+  server: z.string().nonempty("Server is required."),
+  port: z.coerce.number().int().positive("Port must be a positive integer.").default(1433),
+  connectionTimeout: z.coerce.number().int().positive("Connection timeout must be a positive integer.").default(3e4),
+  requestTimeout: z.coerce.number().int().positive("Request timeout must be a positive integer.").default(6e4),
+  pool: z.object({
+    max: z.coerce.number().int().positive("Max pool size must be a positive integer.").default(10),
+    min: z.coerce.number().int().nonnegative("Min pool size must be a non-negative integer.").default(0),
+    idleTimeoutMillis: z.coerce.number().int().nonnegative("Idle timeout must be a non-negative integer.").default(3e4)
+  }),
+  options: z.object({
+    encrypt: z.coerce.boolean().default(false),
+    trustServerCertificate: z.coerce.boolean().default(false)
+  })
+});
+class SqlServerService {
+  connection = null;
+  config;
+  constructor(config2) {
+    this.config = config2;
+  }
+  async dispose() {
+    await this.closeConnection();
+  }
+  /**
+   * Execute a prepared statement and return the results
+   *
+   * @param statementToPrepare The SQL query to prepare
+   * @param params The parameters to bind to the prepared statement
+   * @param paging Optional paging parameters
+   * @returns The entities fetched from the database, along with paging information
+   */
+  async executePreparedStatement(statementToPrepare, params, paging) {
+    const connection = await this.openConnection();
+    const preparedStatement = new sql.PreparedStatement(connection);
+    Object.keys(params).forEach((key) => {
+      preparedStatement.input(key, sql.VarChar);
+    });
+    const finalQuery = paging?.limit !== void 0 ? `${statementToPrepare} OFFSET ${paging.offset || 0} ROWS FETCH NEXT ${paging.limit} ROWS ONLY` : statementToPrepare;
+    await preparedStatement.prepare(finalQuery);
+    let records;
+    try {
+      records = await preparedStatement.execute(params);
+    } catch (error) {
+      const errorInfo = error;
+      const errorMessage = "Error fetching data from ERP -> " + (errorInfo.cause ? `Cause: ${errorInfo.cause}. ` : "") + `Name: ${errorInfo.name}. Message: ${errorInfo.message}. Stack: ${errorInfo.stack}`;
+      throw new Error(errorMessage);
+    } finally {
+      try {
+        await preparedStatement.unprepare();
+      } catch (unprepareError) {
+        logger.error("Error during unprepare:", unprepareError);
+      }
+    }
+    const allRecords = SqlServerService.recordsetToRecords(records?.recordset);
+    const rowsFetched = records?.rowsAffected[0] || 0;
+    const pagedData = paging?.offset !== void 0 ? allRecords.slice(
+      paging.offset,
+      (paging.offset || 0) + (paging.limit || allRecords.length)
+    ) : allRecords;
+    return {
+      data: pagedData,
+      paging: {
+        count: rowsFetched,
+        limit: paging?.limit || 0,
+        offset: paging?.offset || 0,
+        nextPage: (() => {
+          const currentPageEnd = (paging?.offset || 0) + (paging?.limit || 0);
+          return paging?.limit && currentPageEnd < rowsFetched ? String(currentPageEnd) : void 0;
+        })(),
+        previousPage: paging?.offset ? String(Math.max(0, (paging.offset || 0) - (paging.limit || 10))) : void 0
+      }
+    };
+  }
+  /**
+   * Opens a connection to SQL Server
+   * Caches the connection so that it can be reused.
+   * On failure to connect, throws
+   */
+  async openConnection() {
+    if (this.connection?.connected) {
+      logger.debug("Reusing existing SQL Server connection");
+      return this.connection;
+    }
+    if (this.connection) {
+      logger.debug("Clearing disconnected SQL Server connection");
+      this.connection = null;
+    }
+    try {
+      logger.info("Opening new SQL Server connection");
+      const sqlConfig = SQLServerConfigSchema.parse({
+        user: this.config.username,
+        password: this.config.password,
+        database: this.config.database,
+        server: this.config.host,
+        port: parseInt(this.config.port),
+        connectionTimeout: parseInt(this.config.connectionTimeout),
+        requestTimeout: parseInt(this.config.requestTimeout),
+        pool: {
+          max: parseInt(this.config.poolMax),
+          min: parseInt(this.config.poolMin),
+          idleTimeoutMillis: parseInt(this.config.idleTimeoutMillis)
+        },
+        options: {
+          encrypt: this.config.encrypt,
+          trustServerCertificate: this.config.trustServer
+        }
+      });
+      this.connection = await sql.connect(sqlConfig);
+      return this.connection;
+    } catch (error) {
+      logger.error("SqlServerService>>openConnection>> Connection failed", {
+        error
+      });
+      throw new Error("SQL Server connection failed");
+    }
+  }
+  /**
+   * Transform a IRecordSet from a SQL query into an array of Record<string, string> instances.
+   * @param recordset IRecordSet from a SQL query
+   * @returns array of Record<string, string> instances
+   */
+  static recordsetToRecords(recordset) {
+    const data = recordset?.map((row) => {
+      const transformedRow = {};
+      Object.keys(row).forEach((key) => {
+        transformedRow[key] = row[key]?.toString() || "";
+      });
+      return transformedRow;
+    }) || [];
+    return data;
+  }
+  async closeConnection() {
+    if (this.connection?.connected) {
+      logger.info("Closing SQL Server connection");
+      try {
+        await this.connection.close();
+      } catch (error) {
+        logger.error(
+          "SqlServerService::closeConnection: Error closing connection",
+          {
+            error
+          }
+        );
+      }
+      this.connection = null;
+    }
+  }
+}
+class SQLTransactionManager {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  /**
+   * Executes a transaction with the given operation and data, manages rollbacks
+   * @param operation The SQLTransactionOperation to execute
+   * @param data The sql input parameters to pass to the operation
+   * @param config The configuration for the transaction
+   * @returns The result of the operation; throws exceptions on failures
+   */
+  async executeTransaction(operation, data, config2 = {}) {
+    const transaction = new sql.Transaction(this.connection);
+    const isolationLevel = config2.isolationLevel || sql.ISOLATION_LEVEL.READ_COMMITTED;
+    try {
+      await transaction.begin(isolationLevel);
+      const result = await operation.execute(transaction, data);
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      logger.error("Transaction error:", error);
+      try {
+        await transaction.rollback();
+      } catch (rollbackError) {
+        logger.error("Rollback error:", rollbackError);
+      }
+      throw error;
+    }
+  }
+}
+class SQLLaborTicketInsertOperation {
+  constructor(sqlQuery) {
+    this.sqlQuery = sqlQuery;
+  }
+  async execute(transaction, inputs) {
+    const request = transaction.request();
+    inputs.forEach((input) => {
+      request.input(input.name, input.type, input.value);
+    });
+    const result = await request.query(this.sqlQuery);
+    if (!result.recordset[0].NewRowUniqueId) {
+      throw new Error(
+        "No LaborTicketId generated by the labor ticket insert query: " + JSON.stringify(request.parameters, null, 2)
+      );
+    }
+    return result.recordset[0].NewRowUniqueId;
+  }
+}
+class SQLLaborTicketUpdateOperation {
+  constructor(sqlQuery) {
+    this.sqlQuery = sqlQuery;
+  }
+  async execute(transaction, inputs) {
+    const request = transaction.request();
+    inputs.forEach((input) => {
+      request.input(input.name, input.type, input.value);
+    });
+    const result = await request.query(this.sqlQuery);
+    return result.rowsAffected[0];
+  }
+}
+class SqlServerHelper {
+  /**
+   * Creates a new labor ticket in the SQL Server database
+   * Opens but does not close the connection
+   *
+   * @param sqlServerService  The SQL Server service to use for connections
+   * @param laborTicket       The labor ticket to create
+   * @param sqlInputs         The SQL query parameters
+   * @param insertQuery       The SQL query to execute for insertion
+   *
+   * @returns The processed labor ticket, with the ERP's laborTicketId set
+   * Throws exceptions on failures, including if the query does not return a laborTicketId
+   */
+  static async createLaborTicket(sqlServerService, laborTicket, sqlInputs, insertQuery) {
+    const connection = await sqlServerService.openConnection();
+    if (!connection) {
+      throw new Error(
+        "Unable to establish database connection to create labor ticket."
+      );
+    }
+    const transactionManager = new SQLTransactionManager(connection);
+    const laborTicketId = await transactionManager.executeTransaction(
+      new SQLLaborTicketInsertOperation(insertQuery),
+      sqlInputs
+    );
+    if (laborTicketId) {
+      laborTicket.laborTicketId = laborTicketId.toString();
+      return laborTicket;
+    } else {
+      throw new Error(
+        `The query did not return the labor ticket id for labor ticket ref: ${laborTicket.laborTicketRef}`
+      );
+    }
+  }
+  /**
+   * Updates an existing labor ticket in the SQL Server database
+   * Opens but does not close the connection
+   * @param sqlServerService  The SQL Server service to use for connections
+   * @param laborTicket       The labor ticket to update
+   * @param sqlInputs         The SQL query parameters
+   * @param updateQuery       The SQL query to execute for update
+   *
+   * @returns The processed labor ticket
+   * Throws exceptions on failures
+   */
+  static async updateLaborTicket(sqlServerService, laborTicket, sqlInputs, updateQuery) {
+    const connection = await sqlServerService.openConnection();
+    if (!connection) {
+      throw new Error(
+        "Unable to establish database connection to update labor ticket."
+      );
+    }
+    const transactionManager = new SQLTransactionManager(connection);
+    await transactionManager.executeTransaction(
+      new SQLLaborTicketUpdateOperation(updateQuery),
+      sqlInputs
+    );
+    return laborTicket;
+  }
+  /**
+   * Logs the SQL input parameters for debugging
+   */
+  static logQueryInputs(inputs) {
+    logger.info("SQL Input Variables:");
+    logger.info("----------------------------------------");
+    logger.info("Variable Name         | Value");
+    logger.info("----------------------------------------");
+    inputs.forEach((input) => {
+      logger.info(`${input.name.padEnd(20)} | ${input.value}`);
+    });
+    logger.info("----------------------------------------");
+  }
+}
+class PsqlService {
+  config;
+  static odbcModule = null;
+  static odbcLoadError = null;
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Dynamically load the ODBC module with lazy initialization and caching
+   * @throws Error with helpful message if ODBC package is not installed
+   */
+  static async getOdbc() {
+    if (this.odbcLoadError) {
+      throw this.odbcLoadError;
+    }
+    if (this.odbcModule) {
+      return this.odbcModule;
+    }
+    try {
+      const odbcImport = await import("odbc");
+      const odbc = odbcImport.default || odbcImport;
+      this.odbcModule = odbc;
+      return this.odbcModule;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.odbcLoadError = new Error(
+        `ODBC package is required for PSQL service but is not installed or failed to load.
+Install it with: npm install odbc
+Also install OS-level dependencies, e.g. on Alpine Linux:
+  apk add --no-cache unixodbc unixodbc-dev python3 make g++
+For other Linux distributions, install unixodbc and unixodbc-dev packages.
+Original error: ${errorMessage}`
+      );
+      throw this.odbcLoadError;
+    }
+  }
+  // REMOVED: dispose() method - not needed anymore
+  // REMOVED: connection property - not needed anymore
+  // REMOVED: openConnection() method - not needed anymore
+  // REMOVED: closeConnection() method - not needed anymore
+  /**
+   * Build PSQL ODBC connection string
+   * CRITICAL: ServerName must use IP.PORT format (e.g., 10.4.0.11.1583)
+   */
+  buildConnectionString() {
+    const serverName = `${this.config.host}.${this.config.port}`;
+    return [
+      "Driver={Pervasive ODBC Interface}",
+      `ServerName=${serverName}`,
+      `DBQ=${this.config.database}`,
+      `UID=${this.config.username}`,
+      `PWD=${this.config.password}`,
+      "AutoDoubleQuote=0"
+    ].join(";") + ";";
+  }
+  /**
+   * Execute a query and return the results
+   * Creates a fresh connection for each query to avoid handle corruption
+   *
+   * SECURITY WARNING: This method executes the provided SQL string as-is.
+   * - Parameter binding is NOT implemented; the `params` argument is currently ignored.
+   * - Never concatenate untrusted/user-supplied input into `query`.
+   * - Doing so can result in SQL injection vulnerabilities and data exposure.
+   * If dynamic values are required, ensure they are strictly validated/escaped
+   * or implement proper parameterized execution before accepting untrusted input.
+   *
+   * @param query The SQL query to execute
+   * @param params Query parameters (currently unused for PSQL read operations)
+   * @param paging Optional paging parameters
+   * @returns The entities fetched from the database, along with paging information
+   */
+  async executePreparedStatement(query, params = {}, paging) {
+    const odbc = await PsqlService.getOdbc();
+    let connection = null;
+    try {
+      const connStr = this.buildConnectionString();
+      logger.debug("Creating fresh PSQL connection for query");
+      connection = await odbc.connect(connStr);
+      if (Object.keys(params).length > 0) {
+        logger.warn(
+          "PsqlService: Query parameters provided but parameter binding not yet implemented. Using direct query execution."
+        );
+      }
+      const records = await connection.query(query);
+      const allRecords = PsqlService.recordsetToRecords(records);
+      const rowsFetched = allRecords.length;
+      const pagedData = paging?.offset !== void 0 || paging?.limit !== void 0 ? allRecords.slice(
+        paging.offset || 0,
+        (paging.offset || 0) + (paging.limit || allRecords.length)
+      ) : allRecords;
+      return {
+        data: pagedData,
+        paging: {
+          count: rowsFetched,
+          limit: paging?.limit || 0,
+          offset: paging?.offset || 0,
+          nextPage: paging?.limit && (paging.offset || 0) + paging.limit < rowsFetched ? String((paging.offset || 0) + paging.limit) : void 0,
+          previousPage: paging?.offset ? String(Math.max(0, (paging.offset || 0) - (paging.limit || 10))) : void 0
+        }
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ODBC package is required")) {
+        throw error;
+      }
+      const errorInfo = error;
+      logger.error("Error fetching data from PSQL", {
+        error: errorInfo.message,
+        odbcErrors: errorInfo.odbcErrors,
+        query: query.substring(0, 200)
+        // Log first 200 chars of query
+      });
+      throw this.handleOdbcError(errorInfo);
+    } finally {
+      if (connection) {
+        try {
+          await connection.close();
+          logger.debug("PSQL connection closed successfully");
+        } catch (err) {
+          logger.warn("Error closing PSQL connection (non-fatal)", {
+            error: err
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Transform ODBC result set to array of Record<string, string> instances.
+   * IMPORTANT: PSQL CHAR fields are often padded with spaces - we trim them
+   */
+  static recordsetToRecords(recordset) {
+    if (!Array.isArray(recordset)) {
+      return [];
+    }
+    const data = recordset.map((row) => {
+      const transformedRow = {};
+      Object.keys(row).forEach((key) => {
+        const value = row[key];
+        transformedRow[key] = value !== null && value !== void 0 ? String(value).trim() : "";
+      });
+      return transformedRow;
+    });
+    return data;
+  }
+  /**
+   * Handle ODBC errors and provide meaningful messages
+   */
+  handleOdbcError(error) {
+    const odbcError = error.odbcErrors?.[0];
+    const errorCode = odbcError?.state;
+    const message = odbcError?.message || error.message;
+    switch (errorCode) {
+      case "08S01":
+        return new Error(
+          `PSQL connection failed. Check: 1) PVSW environment variable set to /usr/local/psql/etc/pvsw.ini, 2) Network connectivity to ports 1583/3351, 3) ODBC configuration files in /usr/local/psql/etc/ and /etc/. Original error: ${message}`
+        );
+      case "28000":
+        return new Error(
+          `PSQL authentication failed. Check username/password. Original error: ${message}`
+        );
+      case "42000":
+        return new Error(`PSQL SQL syntax error. Original error: ${message}`);
+      case "42S02":
+        return new Error(
+          `PSQL table or view not found. Check table names in query. Original error: ${message}`
+        );
+      default:
+        return new Error(`PSQL error (${errorCode || "unknown"}): ${message}`);
+    }
+  }
+}
+function formatPsqlDate(psqlDate) {
+  if (!psqlDate || psqlDate.trim().length !== 6 || psqlDate === "000000") {
+    return null;
+  }
+  try {
+    const year = parseInt(psqlDate.substring(0, 2), 10);
+    const month = parseInt(psqlDate.substring(2, 4), 10);
+    const day = parseInt(psqlDate.substring(4, 6), 10);
+    const fullYear = year + 2e3;
+    if (month < 1 || month > 12 || day < 1 || day > 31) {
+      return null;
+    }
+    const date = new Date(fullYear, month - 1, day);
+    if (date.getFullYear() !== fullYear || date.getMonth() !== month - 1 || date.getDate() !== day) {
+      return null;
+    }
+    return date.toISOString().split("T")[0];
+  } catch (error) {
+    return null;
+  }
+}
+function formatPsqlTime(psqlTime) {
+  if (!psqlTime) {
+    return null;
+  }
+  const trimmed = psqlTime.trim();
+  if (trimmed.length !== 4) {
+    return null;
+  }
+  try {
+    const hours = parseInt(trimmed.substring(0, 2), 10);
+    const minutes = parseInt(trimmed.substring(2, 4), 10);
+    if (isNaN(hours) || isNaN(minutes) || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+      return null;
+    }
+    const hoursStr = hours.toString().padStart(2, "0");
+    const minutesStr = minutes.toString().padStart(2, "0");
+    return `${hoursStr}:${minutesStr}:00`;
+  } catch (error) {
+    return null;
+  }
+}
+function combinePsqlDateTime(psqlDate, psqlTime) {
+  const date = formatPsqlDate(psqlDate);
+  const time = formatPsqlTime(psqlTime);
+  if (!date || !time) {
+    return null;
+  }
+  return `${date}T${time}`;
+}
+function isPsqlDateEmpty(psqlDate) {
+  return !psqlDate || psqlDate === "000000" || psqlDate.trim() === "";
+}
+function cleanPsqlCharField(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return String(value).trim();
+}
+export {
+  ApplicationInitializer,
+  BatchCacheManager,
+  CoreConfiguration,
+  ERPObjType,
+  E as ErpApiConnectionParams,
+  ErrorHandler,
+  FileLogDeduper,
+  GraphQLError,
+  GraphQLService,
+  HTTPClientFactory,
+  HTTPError,
+  LogEntry,
+  MMApiClient,
+  MMBatchValidationError,
+  MMConnectorLogger,
+  MMReceiveLaborTicket,
+  MMSendLaborTicket,
+  MMSendPart,
+  MMSendPartOperation,
+  MMSendPerson,
+  MMSendReason,
+  MMSendResource,
+  MMSendWorkOrder,
+  MMSendWorkOrderOperation,
+  OAuthClient,
+  PsqlService,
+  RecordTrackingManager,
+  RestAPIService,
+  SqlServerHelper,
+  SqlServerService,
+  StandardProcessDrivers,
+  addNewFieldFromExternalSource,
+  addNewFieldFromLookupField,
+  applyTimezoneOffsetsToFields,
+  buildLogicalCondition,
+  cleanPsqlCharField,
+  cleanupNumbers,
+  combinePsqlDateTime,
+  convertToLocalTime,
+  formatDateWithTZOffset,
+  formatError,
+  formatErrorForLogging,
+  formatPsqlDate,
+  formatPsqlTime,
+  f as getCachedTimezoneName,
+  getCachedTimezoneOffset,
+  g as getErpApiConnectionParams,
+  getErrorType,
+  d as getInitialLoadComplete,
+  getPayloadWithoutIDField,
+  a as getSQLServerConfiguration,
+  getUniqueRows,
+  isPsqlDateEmpty,
+  config as knexDatabaseConfig,
+  logger,
+  removeExtraneousFields,
+  runDataSyncService,
+  e as setInitialLoadComplete,
+  trimObjectValues
+};
+//# sourceMappingURL=mm-erp-sdk.js.map