shipflow 0.1.0 → 0.1.1

package/dist/carriers/aramex/index.js

@@ -0,0 +1,661 @@
+import {
+  APIError,
+  BaseCarrierAdapter,
+  HttpClient,
+  UnsupportedOperationError,
+  ValidationError,
+  validateCreateShipmentInput,
+  validatePickupRequest
+} from "../../index-qjtxhwzv.js";
+
+// src/carriers/aramex/services.ts
+var AramexProductGroup = {
+  EXPRESS: "EXP",
+  DOMESTIC: "DOM"
+};
+var AramexProductType = {
+  DOMESTIC: "OND",
+  PRIORITY_DOCUMENT_EXPRESS: "PDX",
+  PRIORITY_PARCEL_EXPRESS: "PPX",
+  PRIORITY_LETTER_EXPRESS: "PLX",
+  DEFERRED_DOCUMENT_EXPRESS: "DDX",
+  DEFERRED_PARCEL_EXPRESS: "DPX",
+  GROUND_DOCUMENT_EXPRESS: "GDX",
+  GROUND_PARCEL_EXPRESS: "GPX",
+  ECONOMY_PARCEL_EXPRESS: "EPX",
+  RETURN: "RTN"
+};
+var AramexPaymentType = {
+  PREPAID: "P",
+  COLLECT: "C",
+  THIRD_PARTY: "3"
+};
+var AramexService = {
+  COD: "CODS",
+  INSURANCE: "INSR"
+};
+var AramexStatusCodes = {
+  SH001: "created",
+  SH002: "picked_up",
+  SH004: "at_warehouse",
+  SH005: "out_for_delivery",
+  SH014: "delivered",
+  SH060: "in_transit",
+  SH074: "exception",
+  SH159: "exception",
+  SH212: "returned",
+  SH235: "delivered"
+};
+
+// src/carriers/aramex/mappers.ts
+function buildClientInfo(credentials, opts) {
+  return {
+    UserName: credentials.userName,
+    Password: credentials.password,
+    Version: opts?.version ?? "v1.0",
+    AccountNumber: credentials.accountNumber,
+    AccountPin: credentials.accountPin,
+    AccountEntity: credentials.accountEntity,
+    AccountCountryCode: credentials.accountCountryCode,
+    Source: opts?.source ?? 24
+  };
+}
+function mapAramexStatus(updateCode) {
+  const mapped = AramexStatusCodes[updateCode];
+  return mapped;
+}
+function statusFromDescription(description) {
+  if (!description)
+    return;
+  const d = description.toLowerCase();
+  if (/out for delivery|on delivery|with delivery courier/.test(d))
+    return "out_for_delivery";
+  if (/fail|unable|undeliver|exception|held|on hold|problem|refused|damaged/.test(d))
+    return "exception";
+  if (/deliver/.test(d))
+    return "delivered";
+  if (/return/.test(d))
+    return "returned";
+  if (/cancel/.test(d))
+    return "cancelled";
+  if (/picked up|collected|pickup/.test(d))
+    return "picked_up";
+  if (/transit|departed|forwarded|en route/.test(d))
+    return "in_transit";
+  if (/received at|arrived|facility|warehouse|sorting|hub/.test(d))
+    return "at_warehouse";
+  if (/created|information received|booked/.test(d))
+    return "created";
+  return;
+}
+function parseAramexDate(value) {
+  if (!value)
+    return new Date(Number.NaN);
+  const wcf = /\/Date\((-?\d+)(?:[+-]\d{4})?\)\//.exec(value);
+  if (wcf?.[1])
+    return new Date(Number.parseInt(wcf[1], 10));
+  return new Date(value);
+}
+function toWcfDate(date) {
+  return `/Date(${date.getTime()})/`;
+}
+function round(value) {
+  return Math.round(value * 1000) / 1000;
+}
+var VALID_PRODUCT_TYPES = new Set(Object.values(AramexProductType));
+function getMeta(input, key) {
+  const value = input.options?.metadata?.[key];
+  return typeof value === "string" ? value : undefined;
+}
+function resolveProductGroupAndType(input) {
+  const sameCountry = input.shipper.countryCode.trim().toUpperCase() === input.consignee.countryCode.trim().toUpperCase();
+  const metaGroup = getMeta(input, "productGroup")?.toUpperCase();
+  const productGroup = metaGroup === "EXP" || metaGroup === "DOM" ? metaGroup : sameCountry ? "DOM" : "EXP";
+  const candidate = getMeta(input, "productType") ?? input.serviceType;
+  const productType = candidate && VALID_PRODUCT_TYPES.has(candidate) ? candidate : productGroup === "DOM" ? AramexProductType.DOMESTIC : AramexProductType.ECONOMY_PARCEL_EXPRESS;
+  return { productGroup, productType };
+}
+function resolvePaymentType(input) {
+  const meta = getMeta(input, "paymentType");
+  if (meta === "P" || meta === "C" || meta === "3")
+    return meta;
+  return input.cod?.enabled ? "C" : "P";
+}
+function aggregateWeight(input) {
+  const allLb = input.parcels.every((p) => p.weight.unit === "lb");
+  if (allLb) {
+    const value2 = input.parcels.reduce((s, p) => s + p.weight.value, 0);
+    return { Value: round(value2), Unit: "Lb" };
+  }
+  const value = input.parcels.reduce((s, p) => s + (p.weight.unit === "lb" ? p.weight.value * 0.453592 : p.weight.value), 0);
+  return { Value: round(value), Unit: "Kg" };
+}
+function mapDimensions(dims) {
+  if (!dims)
+    return null;
+  const factor = dims.unit === "in" ? 2.54 : 1;
+  return {
+    Length: round(dims.length * factor),
+    Width: round(dims.width * factor),
+    Height: round(dims.height * factor),
+    Unit: "CM"
+  };
+}
+function mapAddress(addr) {
+  return {
+    Line1: addr.line1,
+    Line2: addr.line2 ?? "",
+    Line3: addr.neighbourhood ?? "",
+    City: addr.city,
+    StateOrProvinceCode: addr.state,
+    PostCode: addr.postalCode ?? "",
+    CountryCode: addr.countryCode,
+    Longitude: addr.coordinates?.longitude,
+    Latitude: addr.coordinates?.latitude
+  };
+}
+function buildContact(opts) {
+  return {
+    Department: "",
+    PersonName: opts.personName,
+    Title: "",
+    CompanyName: opts.companyName,
+    PhoneNumber1: opts.phone,
+    PhoneNumber1Ext: "",
+    PhoneNumber2: "",
+    CellPhone: opts.phone,
+    EmailAddress: opts.email ?? "",
+    Type: ""
+  };
+}
+function mapContact(addr, fallbackCompany) {
+  return buildContact({
+    personName: addr.name,
+    companyName: addr.company ?? fallbackCompany ?? addr.name,
+    phone: addr.phone,
+    email: addr.email
+  });
+}
+function mapParty(addr, accountNumber, fallbackCompany) {
+  return {
+    AccountNumber: accountNumber,
+    PartyAddress: mapAddress(addr),
+    Contact: mapContact(addr, fallbackCompany)
+  };
+}
+function mapShipmentDetails(input, productGroup, productType, paymentType) {
+  const numberOfPieces = input.parcels.reduce((s, p) => s + p.pieces, 0) || 1;
+  const description = input.parcels.map((p) => p.description).filter(Boolean).join(", ") || "Goods";
+  const services = [];
+  let cashOnDelivery = null;
+  if (input.cod?.enabled) {
+    cashOnDelivery = {
+      Value: input.cod.amount,
+      CurrencyCode: input.cod.currency
+    };
+    services.push(AramexService.COD);
+  }
+  const customsValue = input.declaredValue ? {
+    Value: input.declaredValue.amount,
+    CurrencyCode: input.declaredValue.currency
+  } : null;
+  const insuranceAmount = input.options?.isInsured && customsValue ? customsValue : null;
+  if (insuranceAmount)
+    services.push(AramexService.INSURANCE);
+  return {
+    Dimensions: mapDimensions(input.parcels[0]?.dimensions),
+    ActualWeight: aggregateWeight(input),
+    ChargeableWeight: null,
+    DescriptionOfGoods: description,
+    GoodsOriginCountry: input.shipper.countryCode,
+    NumberOfPieces: numberOfPieces,
+    ProductGroup: productGroup,
+    ProductType: productType,
+    PaymentType: paymentType,
+    PaymentOptions: "",
+    CustomsValueAmount: customsValue,
+    CashOnDeliveryAmount: cashOnDelivery,
+    InsuranceAmount: insuranceAmount,
+    Services: services.join(",") || undefined
+  };
+}
+function mapCreateShipmentRequest(input, ctx) {
+  const { productGroup, productType } = resolveProductGroupAndType(input);
+  const paymentType = resolvePaymentType(input);
+  const now = new Date;
+  const due = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+  return {
+    Reference1: input.reference,
+    Reference2: input.options?.customerTracking,
+    Shipper: mapParty(input.shipper, ctx.accountNumber, ctx.companyName),
+    Consignee: mapParty(input.consignee),
+    ThirdParty: null,
+    ShippingDateTime: toWcfDate(now),
+    DueDate: toWcfDate(due),
+    Comments: getMeta(input, "comments"),
+    PickupLocation: getMeta(input, "pickupLocation"),
+    Details: mapShipmentDetails(input, productGroup, productType, paymentType),
+    Attachments: null,
+    ForeignHAWB: null,
+    TransportType: 0,
+    Number: null
+  };
+}
+function mapCalculateRateRequest(input, preferredCurrency) {
+  const { productGroup, productType } = resolveProductGroupAndType(input);
+  const paymentType = resolvePaymentType(input);
+  return {
+    OriginAddress: mapAddress(input.shipper),
+    DestinationAddress: mapAddress(input.consignee),
+    ShipmentDetails: mapShipmentDetails(input, productGroup, productType, paymentType),
+    PreferredCurrencyCode: preferredCurrency ?? input.cod?.currency ?? input.declaredValue?.currency
+  };
+}
+function mapPickupRequest(input, ctx) {
+  const pickupDate = new Date(`${input.date}T00:00:00`);
+  const ready = new Date(`${input.date}T09:00:00`);
+  const closing = new Date(`${input.date}T17:00:00`);
+  return {
+    Reference1: input.trackingNumbers?.[0],
+    PickupAddress: {
+      Line1: input.address,
+      City: input.city,
+      CountryCode: ctx.countryCode
+    },
+    PickupContact: buildContact({
+      personName: input.contactName,
+      companyName: ctx.companyName ?? input.contactName,
+      phone: input.contactPhone
+    }),
+    PickupLocation: "Reception",
+    PickupDate: toWcfDate(pickupDate),
+    ReadyTime: toWcfDate(ready),
+    LastPickupTime: toWcfDate(closing),
+    ClosingTime: toWcfDate(closing),
+    Comments: input.timeSlot,
+    Status: "Ready",
+    PickupItems: {
+      PickupItemDetail: [
+        {
+          ProductGroup: "DOM",
+          ProductType: AramexProductType.DOMESTIC,
+          Payment: "P",
+          NumberOfShipments: input.shipmentCount,
+          NumberOfPieces: input.shipmentCount,
+          ShipmentWeight: { Value: 1, Unit: "Kg" }
+        }
+      ]
+    }
+  };
+}
+function mapShipmentResponse(processed, input) {
+  const trackingNumber = processed.ID || processed.ShipmentNumber || "";
+  const labelUrl = processed.ShipmentLabel?.LabelURL || undefined;
+  return {
+    carrier: "aramex",
+    trackingNumber,
+    customerTracking: input?.options?.customerTracking,
+    reference: input?.reference,
+    status: "created",
+    statusLabel: "Created",
+    labelUrl,
+    pdfLabelUrl: labelUrl,
+    codAmount: input?.cod?.enabled ? input.cod.amount : undefined,
+    declaredValue: input?.declaredValue?.amount,
+    currency: input?.cod?.currency ?? input?.declaredValue?.currency ?? "SAR",
+    createdAt: new Date,
+    raw: processed
+  };
+}
+function mapTrackingEvent(result) {
+  return {
+    timestamp: parseAramexDate(result.UpdateDateTime),
+    statusCode: result.UpdateCode,
+    status: mapAramexStatus(result.UpdateCode) ?? statusFromDescription(result.UpdateDescription) ?? "unknown",
+    description: result.UpdateDescription,
+    location: result.UpdateLocation || undefined
+  };
+}
+function mapTrackingResult(waybill, results) {
+  const events = results.map(mapTrackingEvent).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  const latest = events[0];
+  const delivered = events.find((e) => e.status === "delivered");
+  const weightStr = [...results].reverse().find((r) => r.GrossWeight)?.GrossWeight;
+  const weight = weightStr ? Number.parseFloat(weightStr) : undefined;
+  return {
+    trackingNumber: waybill,
+    carrier: "aramex",
+    status: latest?.status ?? "unknown",
+    statusLabel: latest?.description ?? "Unknown",
+    events,
+    deliveryDate: delivered?.timestamp,
+    weight: weight != null && !Number.isNaN(weight) ? weight : undefined,
+    raw: results
+  };
+}
+function normalizeTrackingResults(raw) {
+  if (!raw)
+    return {};
+  if (Array.isArray(raw)) {
+    const map = {};
+    for (const kv of raw) {
+      if (kv && typeof kv === "object" && "Key" in kv) {
+        map[kv.Key] = kv.Value ?? [];
+      }
+    }
+    return map;
+  }
+  return raw;
+}
+function mapRate(response, input) {
+  const { productType } = resolveProductGroupAndType(input);
+  return {
+    carrier: "aramex",
+    serviceType: productType,
+    serviceName: productType,
+    amount: response.TotalAmount?.Value ?? 0,
+    currency: response.TotalAmount?.CurrencyCode ?? input.cod?.currency ?? input.declaredValue?.currency ?? "SAR",
+    raw: response
+  };
+}
+function mapPickupResponse(processed, input) {
+  return {
+    id: processed.GUID || processed.ID,
+    carrier: "aramex",
+    status: "pending",
+    date: input.date,
+    timeSlot: input.timeSlot,
+    city: input.city,
+    contactName: input.contactName,
+    contactPhone: input.contactPhone,
+    address: input.address,
+    shipmentCount: input.shipmentCount,
+    createdAt: new Date,
+    raw: processed
+  };
+}
+function mapCity(name) {
+  return { nameEn: name };
+}
+function mapOffice(office) {
+  const addr = office.Address;
+  const lines = [addr?.Line1, addr?.Line2, addr?.Line3].filter(Boolean);
+  return {
+    id: office.EntityCode,
+    name: office.EntityName ?? office.EntityCode,
+    address: lines.length ? lines.join(", ") : undefined,
+    city: addr?.City,
+    latitude: addr?.Latitude,
+    longitude: addr?.Longitude
+  };
+}
+
+// src/carriers/aramex/adapter.ts
+var SHIPPING_SANDBOX_URL = "https://ws.dev.aramex.net/ShippingAPI.V2/Shipping/Service_1_0.svc";
+var SHIPPING_PRODUCTION_URL = "https://ws.aramex.net/ShippingAPI.V2/Shipping/Service_1_0.svc";
+var DEFAULT_LABEL_INFO = {
+  ReportID: 9201,
+  ReportType: "URL"
+};
+var EMPTY_TRANSACTION = {
+  Reference1: "",
+  Reference2: "",
+  Reference3: "",
+  Reference4: "",
+  Reference5: ""
+};
+
+class AramexAdapter extends BaseCarrierAdapter {
+  name = "aramex";
+  supportedCountries = [
+    "SA",
+    "AE",
+    "BH",
+    "KW",
+    "OM",
+    "QA",
+    "JO",
+    "EG",
+    "LB",
+    "IQ"
+  ];
+  shippingHttp;
+  trackingHttp;
+  rateHttp;
+  locationHttp;
+  constructor(config) {
+    super(config);
+    const shippingBase = this.getBaseUrl();
+    const common = {
+      carrier: "aramex"
+    };
+    this.shippingHttp = new HttpClient({ ...common, baseUrl: shippingBase });
+    this.trackingHttp = new HttpClient({
+      ...common,
+      baseUrl: this.serviceBase(shippingBase, "Tracking")
+    });
+    this.rateHttp = new HttpClient({
+      ...common,
+      baseUrl: this.serviceBase(shippingBase, "RateCalculator")
+    });
+    this.locationHttp = new HttpClient({
+      ...common,
+      baseUrl: config.locationBaseUrl ?? this.serviceBase(shippingBase, "Location")
+    });
+  }
+  getBaseUrl() {
+    return this.config.mode === "production" ? SHIPPING_PRODUCTION_URL : SHIPPING_SANDBOX_URL;
+  }
+  serviceBase(shippingBase, service) {
+    return shippingBase.replace("/Shipping/", `/${service}/`);
+  }
+  get aramexConfig() {
+    return this.config;
+  }
+  buildClientInfo() {
+    const cfg = this.aramexConfig;
+    return buildClientInfo(cfg.credentials, {
+      source: cfg.source,
+      version: cfg.version
+    });
+  }
+  static aramexErrorExtractor(json) {
+    const obj = json;
+    const notifications = obj?.Notifications ?? [];
+    const hasError = obj?.HasErrors === true;
+    const message = notifications.map((n) => n?.Message).filter(Boolean).join("; ") || (hasError ? "Aramex returned an error" : undefined);
+    return {
+      hasError,
+      message,
+      errors: notifications.length ? AramexAdapter.notificationsToErrors(notifications) : undefined
+    };
+  }
+  static notificationsToErrors(notifications) {
+    return {
+      _aramex: notifications.map((n) => `${n?.Code ?? ""}: ${n?.Message ?? ""}`.trim())
+    };
+  }
+  async executeCreateShipment(input) {
+    const cfg = this.aramexConfig;
+    const shipment = mapCreateShipmentRequest(input, {
+      accountNumber: cfg.credentials.accountNumber,
+      companyName: cfg.companyName
+    });
+    const response = await this.shippingHttp.post("/json/CreateShipments", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      LabelInfo: DEFAULT_LABEL_INFO,
+      Shipments: [shipment]
+    }, { errorExtractor: AramexAdapter.aramexErrorExtractor });
+    const processed = response.Shipments?.[0];
+    if (!processed) {
+      throw new APIError("Aramex returned no shipment", {
+        carrier: "aramex",
+        raw: response
+      });
+    }
+    if (processed.HasErrors) {
+      const notifications = processed.Notifications ?? [];
+      throw new APIError(notifications.map((n) => n.Message).filter(Boolean).join("; ") || "Failed to create shipment", {
+        carrier: "aramex",
+        errors: AramexAdapter.notificationsToErrors(notifications),
+        raw: processed
+      });
+    }
+    return mapShipmentResponse(processed, input);
+  }
+  async createBulkShipments(inputs) {
+    if (inputs.length === 0) {
+      throw new ValidationError("At least one shipment is required for bulk create", { raw: { count: 0 } });
+    }
+    for (const input of inputs)
+      validateCreateShipmentInput(input);
+    const cfg = this.aramexConfig;
+    const shipments = inputs.map((input) => mapCreateShipmentRequest(input, {
+      accountNumber: cfg.credentials.accountNumber,
+      companyName: cfg.companyName
+    }));
+    const response = await this.shippingHttp.post("/json/CreateShipments", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      LabelInfo: DEFAULT_LABEL_INFO,
+      Shipments: shipments
+    }, { errorExtractor: AramexAdapter.aramexErrorExtractor });
+    const processed = response.Shipments ?? [];
+    if (processed.length === 0) {
+      throw new APIError("Aramex returned no shipments", {
+        carrier: "aramex",
+        raw: response
+      });
+    }
+    const failed = processed.filter((p) => p.HasErrors);
+    if (failed.length > 0) {
+      const notifications = failed.flatMap((p) => p.Notifications ?? []);
+      throw new APIError(notifications.map((n) => n.Message).filter(Boolean).join("; ") || `Failed to create ${failed.length} of ${processed.length} shipments`, {
+        carrier: "aramex",
+        errors: AramexAdapter.notificationsToErrors(notifications),
+        raw: response
+      });
+    }
+    return processed.map((p, i) => mapShipmentResponse(p, inputs[i]));
+  }
+  cancelShipment(_trackingNumber) {
+    throw new UnsupportedOperationError("aramex", "cancelShipment");
+  }
+  async getLabel(trackingNumber, _format) {
+    const response = await this.shippingHttp.post("/json/PrintLabel", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      ShipmentNumber: trackingNumber,
+      LabelInfo: DEFAULT_LABEL_INFO
+    }, { errorExtractor: AramexAdapter.aramexErrorExtractor });
+    const url = response.ShipmentLabel?.LabelURL;
+    if (!url) {
+      throw new APIError("Failed to get label", {
+        carrier: "aramex",
+        raw: response
+      });
+    }
+    return url;
+  }
+  async track(trackingNumber) {
+    const results = await this.trackMultiple([trackingNumber]);
+    const result = results[0];
+    if (!result) {
+      throw new APIError("Shipment not found", {
+        carrier: "aramex",
+        raw: { trackingNumber }
+      });
+    }
+    return result;
+  }
+  async trackMultiple(trackingNumbers) {
+    const response = await this.trackingHttp.post("/json/TrackShipments", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      Shipments: trackingNumbers,
+      GetLastTrackingUpdateOnly: false
+    }, { retry: true, errorExtractor: AramexAdapter.aramexErrorExtractor });
+    const map = normalizeTrackingResults(response.TrackingResults);
+    return Object.entries(map).map(([waybill, results]) => mapTrackingResult(waybill, results));
+  }
+  async trackByReference(reference) {
+    const result = await this.track(reference);
+    return { ...result, reference };
+  }
+  async getRates(input) {
+    const rateRequest = mapCalculateRateRequest(input);
+    const response = await this.rateHttp.post("/json/CalculateRate", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      ...rateRequest
+    }, { retry: true, errorExtractor: AramexAdapter.aramexErrorExtractor });
+    if (response.TotalAmount?.Value == null) {
+      throw new APIError("Aramex returned no rate for this shipment", {
+        carrier: "aramex",
+        raw: response
+      });
+    }
+    return [mapRate(response, input)];
+  }
+  async createPickup(input) {
+    validatePickupRequest(input);
+    const cfg = this.aramexConfig;
+    const pickup = mapPickupRequest(input, {
+      accountNumber: cfg.credentials.accountNumber,
+      countryCode: cfg.credentials.accountCountryCode,
+      companyName: cfg.companyName
+    });
+    const response = await this.shippingHttp.post("/json/CreatePickup", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      Pickup: pickup
+    }, { errorExtractor: AramexAdapter.aramexErrorExtractor });
+    const processed = response.ProcessedPickup;
+    if (!processed || !processed.GUID && !processed.ID) {
+      throw new APIError("Failed to create pickup", {
+        carrier: "aramex",
+        raw: response
+      });
+    }
+    return mapPickupResponse(processed, input);
+  }
+  async cancelPickup(pickupId) {
+    const response = await this.shippingHttp.post("/json/CancelPickup", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      PickupGUID: String(pickupId)
+    }, { errorExtractor: AramexAdapter.aramexErrorExtractor });
+    return response.HasErrors !== true;
+  }
+  async getCities(countryCode) {
+    const response = await this.locationHttp.post("/json/FetchCities", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      CountryCode: countryCode ?? this.aramexConfig.credentials.accountCountryCode
+    }, { retry: true, errorExtractor: AramexAdapter.aramexErrorExtractor });
+    return (response.Cities ?? []).map(mapCity);
+  }
+  async getDropoffLocations(countryCode) {
+    const response = await this.locationHttp.post("/json/FetchOffices", {
+      ClientInfo: this.buildClientInfo(),
+      Transaction: EMPTY_TRANSACTION,
+      CountryCode: countryCode ?? this.aramexConfig.credentials.accountCountryCode
+    }, { retry: true, errorExtractor: AramexAdapter.aramexErrorExtractor });
+    return (response.Offices ?? []).map(mapOffice);
+  }
+}
+export {
+  statusFromDescription,
+  parseAramexDate,
+  mapAramexStatus,
+  buildClientInfo,
+  AramexStatusCodes,
+  AramexService,
+  AramexProductType,
+  AramexProductGroup,
+  AramexPaymentType,
+  AramexAdapter
+};
+
+//# debugId=F2518B67CA4397C364756E2164756E21