@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/integrations/exact-online.js

@@ -0,0 +1,1089 @@
+import { createPage, PLATFORM_PASSTHROUGH_KEYS, readRestPage, ValidationError, } from '@sixtyninecommerce/core';
+import { fieldOf } from '../catalog/types.js';
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
+/** The most sync-log rows one {@link ExactOnlineSyncModule.logs} read answers. */
+export const EXACT_ONLINE_SYNC_LOG_LIMIT = 100;
+const SYNC_WINDOW_FIELDS = /* GraphQL */ `enabled intervalMinutes`;
+const CONFIG_FIELDS = /* GraphQL */ `
+  id
+  enabled
+  connected
+  region
+  division
+  companyName
+  clientId
+  hasCustomCredentials
+  hasWebhookSecret
+  lastConnectedAt
+  lastRefreshedAt
+  accessTokenExpiresAt
+  shippingItemCode
+  discountItemCode
+  externalLineItemCode
+  pushSurcharges
+  surchargeItemCode
+  negativeSurchargeItemCode
+  pushSurchargesWarning
+  autoPush { enabled defaultTrigger rules { customerGroupId trigger } }
+  customerSync {
+    enabled
+    webhookEnabled
+    pushEnabled
+    accountFilter
+    overwritePolicy
+    fields { name email address }
+  }
+  paymentTerms {
+    enabled
+    synchronizationEnabled
+    newAccountPaymentConditionCode
+    paymentMethodConditions { paymentMethodId conditionCode }
+  }
+  deliveryTerms {
+    enabled
+    synchronizationEnabled
+    forwardRequestedDeliveryDate
+    sendDeliveryAddress
+    newAccountShippingMethodId
+    newAccountIncotermCode
+    newAccountIncotermVersion
+    newAccountIncotermAddress
+    newAccountShippingLeadDays
+    newAccountDeliveryAdvice
+  }
+  syncSchedule {
+    delta { ${SYNC_WINDOW_FIELDS} }
+    full { ${SYNC_WINDOW_FIELDS} }
+    order { ${SYNC_WINDOW_FIELDS} }
+    purchaseOrders { ${SYNC_WINDOW_FIELDS} }
+    purchaseOrdersReconcile { ${SYNC_WINDOW_FIELDS} }
+    customers { ${SYNC_WINDOW_FIELDS} }
+    priceLists { ${SYNC_WINDOW_FIELDS} }
+    dailyCallBudget
+  }
+  catalogueImportPolicy {
+    requireWebshopFlag
+    nonStockItems
+    unpricedItems
+    priceBasis
+    pictures
+    stockBasis
+  }
+  deltaLastEnqueuedAt
+  fullLastEnqueuedAt
+  orderLastEnqueuedAt
+  purchaseOrderLastEnqueuedAt
+  purchaseOrderReconcileLastEnqueuedAt
+  customerLastEnqueuedAt
+  priceListLastEnqueuedAt
+`;
+/**
+ * `updateExactOnlineConfig`'s inline arguments, each with its GraphQL type: the SDK takes one
+ * object, the wire keeps the arguments (adding an input type would be a second door to keep).
+ */
+export const EXACT_ONLINE_CONFIG_ARGUMENTS = {
+    region: 'String',
+    enabled: 'Boolean',
+    shippingItemCode: 'String',
+    discountItemCode: 'String',
+    externalLineItemCode: 'String',
+    pushSurcharges: 'Boolean',
+    surchargeItemCode: 'String',
+    negativeSurchargeItemCode: 'String',
+    autoPush: 'ExactAutoPushConfigInput',
+    customerSync: 'ExactCustomerSyncConfigInput',
+    paymentTerms: 'ExactPaymentTermsConfigInput',
+    deliveryTerms: 'ExactDeliveryTermsConfigInput',
+    syncSchedule: 'ExactSyncScheduleInput',
+    catalogueImportPolicy: 'ExactCatalogueImportPolicyInput',
+};
+/** The keys the engine cannot store as `null` (a not-null column, a `.trim()`, a section read). */
+const NEVER_NULL_CONFIG_KEYS = [
+    'region',
+    'enabled',
+    'shippingItemCode',
+    'discountItemCode',
+    'paymentTerms',
+    'deliveryTerms',
+];
+export const EXACT_ONLINE_CONFIG_QUERY = /* GraphQL */ `
+  query ExactOnlineConfig {
+    exactOnlineConfig { ${CONFIG_FIELDS} }
+  }
+`;
+// The variable list and the arguments are written out, never spliced in from
+// EXACT_ONLINE_CONFIG_ARGUMENTS: the package's coverage specs parse every document literal with
+// each `${…}` read as a field name, so an interpolated variable list fails them. The SDK spec
+// pins the variables against the map and the engine's arguments.
+export const UPDATE_EXACT_ONLINE_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdateExactOnlineConfig(
+    $region: String
+    $enabled: Boolean
+    $shippingItemCode: String
+    $discountItemCode: String
+    $externalLineItemCode: String
+    $pushSurcharges: Boolean
+    $surchargeItemCode: String
+    $negativeSurchargeItemCode: String
+    $autoPush: ExactAutoPushConfigInput
+    $customerSync: ExactCustomerSyncConfigInput
+    $paymentTerms: ExactPaymentTermsConfigInput
+    $deliveryTerms: ExactDeliveryTermsConfigInput
+    $syncSchedule: ExactSyncScheduleInput
+    $catalogueImportPolicy: ExactCatalogueImportPolicyInput
+  ) {
+    updateExactOnlineConfig(
+      region: $region
+      enabled: $enabled
+      shippingItemCode: $shippingItemCode
+      discountItemCode: $discountItemCode
+      externalLineItemCode: $externalLineItemCode
+      pushSurcharges: $pushSurcharges
+      surchargeItemCode: $surchargeItemCode
+      negativeSurchargeItemCode: $negativeSurchargeItemCode
+      autoPush: $autoPush
+      customerSync: $customerSync
+      paymentTerms: $paymentTerms
+      deliveryTerms: $deliveryTerms
+      syncSchedule: $syncSchedule
+      catalogueImportPolicy: $catalogueImportPolicy
+    ) {
+      ${CONFIG_FIELDS}
+    }
+  }
+`;
+export const SET_EXACT_ONLINE_CREDENTIALS_MUTATION = /* GraphQL */ `
+  mutation SetExactOnlineCredentials(
+    $clientId: String!
+    $clientSecret: String
+    $webhookSecret: String
+  ) {
+    setExactOnlineCredentials(
+      clientId: $clientId
+      clientSecret: $clientSecret
+      webhookSecret: $webhookSecret
+    ) {
+      ${CONFIG_FIELDS}
+    }
+  }
+`;
+export const EXACT_ONLINE_AUTHORIZATION_URL_MUTATION = /* GraphQL */ `
+  mutation ExactOnlineAuthorizationUrl($region: String) {
+    exactOnlineAuthorizationUrl(region: $region)
+  }
+`;
+export const DISCONNECT_EXACT_ONLINE_MUTATION = /* GraphQL */ `
+  mutation DisconnectExactOnline {
+    disconnectExactOnline
+  }
+`;
+export const EXACT_ONLINE_SAMPLE_ACCOUNTS_QUERY = /* GraphQL */ `
+  query ExactOnlineSampleAccounts($limit: Int) {
+    exactOnlineSampleAccounts(limit: $limit) { id code name city country email status }
+  }
+`;
+export const EXACT_ONLINE_SAMPLE_ITEMS_QUERY = /* GraphQL */ `
+  query ExactOnlineSampleItems($limit: Int) {
+    exactOnlineSampleItems(limit: $limit) { id code description isSalesItem isStockItem }
+  }
+`;
+export const EXACT_ONLINE_CATALOGUE_STRUCTURE_QUERY = /* GraphQL */ `
+  query ExactOnlineCatalogueStructure($sample: Int) {
+    exactOnlineCatalogueStructure(sample: $sample) {
+      sampledCount
+      distinctItemGroupCount
+      topItemGroups { code description itemCount }
+      classFields { field nonEmptyCount distinctCount }
+      rows { code description itemGroup }
+    }
+  }
+`;
+export const EXACT_ONLINE_CUSTOMER_STRUCTURE_QUERY = /* GraphQL */ `
+  query ExactOnlineCustomerStructure($sample: Int) {
+    exactOnlineCustomerStructure(sample: $sample) {
+      sampledCount
+      withEmail
+      withoutEmail
+      withAddress
+      resellerCount
+      dimensions {
+        sequence
+        name
+        slotField
+        populatedCount
+        distinctCount
+        values { id code description accountCount }
+      }
+      priceLists { id code description accountCount }
+      rows { code name email city country isReseller classifications priceList }
+    }
+  }
+`;
+export const EXACT_ONLINE_PRICING_STRUCTURE_QUERY = /* GraphQL */ `
+  query ExactOnlinePricingStructure {
+    exactOnlinePricingStructure {
+      priceLists { id code description currency }
+      priceListItemPriceCount
+      priceListItemSamples {
+        itemCode
+        itemDescription
+        quantity
+        newPrice
+        discount
+        entryMethod
+        basePrice
+      }
+      accountsWithDefaultPriceList
+      customerPriceCount
+      customerPriceDistinctAccounts
+      customerPriceDistinctItems
+      customerPriceSamples { itemCode accountName price quantity currency }
+      sampled
+    }
+  }
+`;
+export const EXACT_ONLINE_WEBHOOK_STATUS_QUERY = /* GraphQL */ `
+  query ExactOnlineWebhookStatus {
+    exactOnlineWebhookStatus {
+      supported
+      registered
+      subscriptions { topic subscriptionId callbackUrl }
+      checkedAt
+      error
+    }
+  }
+`;
+export const SYNC_EXACT_ONLINE_WEBHOOKS_MUTATION = /* GraphQL */ `
+  mutation SyncExactOnlineWebhooks {
+    syncExactOnlineWebhooks
+  }
+`;
+const SWEEP_ESTIMATE_FIELDS = /* GraphQL */ `
+  enabled
+  intervalMinutes
+  minIntervalMinutes
+  maxIntervalMinutes
+  callsPerRun
+  runsPerDay
+  callsPerDay
+`;
+export const EXACT_ONLINE_SYNC_ESTIMATE_QUERY = /* GraphQL */ `
+  query ExactOnlineSyncEstimate($schedule: ExactSyncScheduleInput!) {
+    exactOnlineSyncEstimate(schedule: $schedule) {
+      delta { ${SWEEP_ESTIMATE_FIELDS} }
+      full { ${SWEEP_ESTIMATE_FIELDS} }
+      order { ${SWEEP_ESTIMATE_FIELDS} }
+      purchaseOrders { ${SWEEP_ESTIMATE_FIELDS} }
+      purchaseOrdersReconcile { ${SWEEP_ESTIMATE_FIELDS} }
+      customers { ${SWEEP_ESTIMATE_FIELDS} }
+      priceLists { ${SWEEP_ESTIMATE_FIELDS} }
+      total
+      dailyCallBudget
+      overBudget
+    }
+  }
+`;
+const SYNC_LOG_FIELDS = /* GraphQL */ `
+  id
+  entity
+  mode
+  status
+  createdCount
+  updatedCount
+  skippedCount
+  failedCount
+  detachedCount
+  error
+  durationMs
+  createdAt
+  catalogueExclusions { inactive notWebshop nonStock unpriced total absent }
+`;
+export const EXACT_ONLINE_SYNC_LOGS_QUERY = /* GraphQL */ `
+  query ExactOnlineSyncLogs($limit: Int, $entity: String) {
+    exactOnlineSyncLogs(limit: $limit, entity: $entity) { ${SYNC_LOG_FIELDS} }
+  }
+`;
+const RUN_SUMMARY_FIELDS = /* GraphQL */ `lastRunAt status error lastSuccessAt`;
+export const EXACT_ONLINE_SYNC_HEALTH_QUERY = /* GraphQL */ `
+  query ExactOnlineSyncHealth {
+    exactOnlineSyncHealth {
+      customers { ${RUN_SUMMARY_FIELDS} }
+      catalogue { ${RUN_SUMMARY_FIELDS} }
+      orders { ${RUN_SUMMARY_FIELDS} }
+    }
+  }
+`;
+export const RUN_EXACT_ONLINE_CATALOGUE_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineCatalogueSync {
+    runExactOnlineCatalogueSync
+  }
+`;
+export const RUN_EXACT_ONLINE_CUSTOMER_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineCustomerSync {
+    runExactOnlineCustomerSync
+  }
+`;
+export const RUN_EXACT_ONLINE_PRICE_LIST_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlinePriceListSync {
+    runExactOnlinePriceListSync
+  }
+`;
+export const REIMPORT_EXACT_ONLINE_ITEM_PICTURES_MUTATION = /* GraphQL */ `
+  mutation ReimportExactOnlineItemPictures {
+    reimportExactOnlineItemPictures
+  }
+`;
+export const EXACT_ONLINE_SYNC_CURSORS_QUERY = /* GraphQL */ `
+  query ExactOnlineSyncCursors {
+    exactOnlineSyncCursors { entity cursor }
+  }
+`;
+export const RESET_EXACT_ONLINE_SYNC_CURSOR_MUTATION = /* GraphQL */ `
+  mutation ResetExactOnlineSyncCursor($entity: String!) {
+    resetExactOnlineSyncCursor(entity: $entity)
+  }
+`;
+export const EXACT_ONLINE_WAREHOUSE_LINKS_QUERY = /* GraphQL */ `
+  query ExactOnlineWarehouseLinks {
+    exactOnlineWarehouseLinks { stockLocationId stockLocationName exactWarehouseId }
+  }
+`;
+const SHIPPING_MAPPING_FIELDS = /* GraphQL */ `
+  vendureShippingMethodId
+  vendureCode
+  vendureName
+  exactShippingMethodId
+  exactManaged
+  status
+`;
+export const EXACT_ONLINE_SHIPPING_METHODS_QUERY = /* GraphQL */ `
+  query ExactOnlineShippingMethods {
+    exactOnlineShippingMethods {
+      mappings { ${SHIPPING_MAPPING_FIELDS} }
+      exact { id code description active amount linked }
+    }
+  }
+`;
+export const RUN_EXACT_ONLINE_SHIPPING_METHOD_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineShippingMethodSync {
+    runExactOnlineShippingMethodSync
+  }
+`;
+export const IMPORT_EXACT_ONLINE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation ImportExactOnlineShippingMethod($exactShippingMethodId: String!) {
+    importExactOnlineShippingMethod(exactShippingMethodId: $exactShippingMethodId) {
+      ${SHIPPING_MAPPING_FIELDS}
+    }
+  }
+`;
+export const SET_EXACT_ONLINE_SHIPPING_METHOD_MAPPING_MUTATION = /* GraphQL */ `
+  mutation SetExactOnlineShippingMethodMapping(
+    $vendureShippingMethodId: ID!
+    $exactShippingMethodId: String
+  ) {
+    setExactOnlineShippingMethodMapping(
+      vendureShippingMethodId: $vendureShippingMethodId
+      exactShippingMethodId: $exactShippingMethodId
+    ) {
+      ${SHIPPING_MAPPING_FIELDS}
+    }
+  }
+`;
+export const CONVERT_EXACT_ONLINE_SHIPPING_METHOD_TO_MAPPING_MUTATION = /* GraphQL */ `
+  mutation ConvertExactOnlineShippingMethodToMapping(
+    $exactShippingMethodId: String!
+    $vendureShippingMethodId: ID!
+  ) {
+    convertExactOnlineShippingMethodToMapping(
+      exactShippingMethodId: $exactShippingMethodId
+      vendureShippingMethodId: $vendureShippingMethodId
+    ) {
+      ${SHIPPING_MAPPING_FIELDS}
+    }
+  }
+`;
+export const RETIRE_EXACT_ONLINE_IMPORTED_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation RetireExactOnlineImportedShippingMethod($exactShippingMethodId: String!) {
+    retireExactOnlineImportedShippingMethod(exactShippingMethodId: $exactShippingMethodId)
+  }
+`;
+// ── Payment and delivery terms (W10-57) ──
+const PAYMENT_CONDITION_DISTRIBUTION_FIELDS = /* GraphQL */ `code description customerCount`;
+const UNRESOLVED_PAYMENT_CONDITION_FIELDS = /* GraphQL */ `code customerCount`;
+const DRY_RUN_RESOURCE_FIELDS = /* GraphQL */ `resource ok permissionWarning error`;
+export const EXACT_ONLINE_PAYMENT_CONDITIONS_QUERY = /* GraphQL */ `
+  query ExactOnlinePaymentConditions {
+    exactOnlinePaymentConditions {
+      exactId
+      code
+      description
+      summary
+      classification
+      paymentDays
+      paymentEndOfMonths
+      paymentMethod
+      percentage
+      discountPaymentDays
+      discountPercentage
+      paymentDiscountType
+      active
+      syncedAt
+    }
+  }
+`;
+export const EXACT_ONLINE_PAYMENT_TERMS_DIAGNOSTICS_QUERY = /* GraphQL */ `
+  query ExactOnlinePaymentTermsDiagnostics {
+    exactOnlinePaymentTermsDiagnostics {
+      totalCustomers
+      assignedCount
+      unassignedCount
+      unresolvedCount
+      staleCount
+      lastSyncedAt
+      error
+      permissionWarning
+      distribution { ${PAYMENT_CONDITION_DISTRIBUTION_FIELDS} }
+      unresolvedCodes { ${UNRESOLVED_PAYMENT_CONDITION_FIELDS} }
+      lastReconciliation {
+        mode
+        status
+        createdCount
+        updatedCount
+        deactivatedCount
+        failedCount
+        at
+        error
+      }
+    }
+  }
+`;
+const DRY_RUN_CONDITION_FIELDS = /* GraphQL */ `code description summary classification scheduleCount`;
+export const EXACT_ONLINE_PAYMENT_TERMS_DRY_RUN_QUERY = /* GraphQL */ `
+  query ExactOnlinePaymentTermsDryRun {
+    exactOnlinePaymentTermsDryRun {
+      division
+      generatedAt
+      complete
+      permissionWarning
+      catalogRowCount
+      catalogCodeCount
+      accountCount
+      assignedCount
+      unassignedCount
+      unresolvedCount
+      uncheckedCount
+      distribution { ${PAYMENT_CONDITION_DISTRIBUTION_FIELDS} }
+      duplicateConditions { ${DRY_RUN_CONDITION_FIELDS} }
+      complexConditions { ${DRY_RUN_CONDITION_FIELDS} }
+      unresolvedCodes { ${UNRESOLVED_PAYMENT_CONDITION_FIELDS} }
+      assignmentIssues { accountId accountCode conditionCode conditionDescription status }
+      resources { ${DRY_RUN_RESOURCE_FIELDS} }
+    }
+  }
+`;
+export const EXACT_ONLINE_INCOTERMS_QUERY = /* GraphQL */ `
+  query ExactOnlineIncoterms {
+    exactOnlineIncoterms {
+      exactId
+      code
+      version
+      description
+      catalogAvailable
+      stale
+      lastSyncedAt
+      error
+    }
+  }
+`;
+export const EXACT_ONLINE_DELIVERY_TERMS_DIAGNOSTICS_QUERY = /* GraphQL */ `
+  query ExactOnlineDeliveryTermsDiagnostics {
+    exactOnlineDeliveryTermsDiagnostics {
+      reconciliationRequired
+      accountSyncStatus
+      totalCustomers
+      assignedCount
+      unassignedCount
+      unresolvedCount
+      staleCount
+      mappedMethodCount
+      usableShippingMappingCount
+      unmappedMethodCount
+      inactiveMethodCount
+      unavailableMethodCount
+      nullAmountCount
+      invalidIncotermCount
+      lastSyncedAt
+      error
+      permissionWarning
+      shippingMethodDistribution { exactId code description customerCount }
+      incotermDistribution { code version description customerCount }
+      warnings
+    }
+  }
+`;
+export const EXACT_ONLINE_DELIVERY_TERMS_DRY_RUN_QUERY = /* GraphQL */ `
+  query ExactOnlineDeliveryTermsDryRun {
+    exactOnlineDeliveryTermsDryRun {
+      division
+      generatedAt
+      complete
+      permissionWarning
+      shippingMethodCount
+      activeShippingMethodCount
+      mappingCount
+      unmappedCatalogMethodCount
+      nullAmountCount
+      zeroAmountCount
+      incotermCount
+      accountCount
+      assignedShippingMethodCount
+      mappedAssignedShippingMethodCount
+      unmappedAssignedShippingMethodCount
+      unassignedShippingMethodCount
+      unresolvedShippingMethodCount
+      assignedIncotermCount
+      unassignedIncotermCount
+      unresolvedIncotermCount
+      invalidPolicyCount
+      shippingMethodDistribution { exactId customerCount }
+      incotermDistribution { code version customerCount }
+      assignmentIssues {
+        accountId
+        accountCode
+        shippingMethodId
+        incotermCode
+        incotermVersion
+        status
+        message
+      }
+      resources { ${DRY_RUN_RESOURCE_FIELDS} }
+    }
+  }
+`;
+// ── The customer, order and product cards (W10-57) ──
+export const EXACT_ONLINE_CUSTOMER_PAYMENT_TERMS_QUERY = /* GraphQL */ `
+  query ExactOnlineCustomerPaymentTerms($customerId: ID!) {
+    exactOnlineCustomerPaymentTerms(customerId: $customerId) {
+      customerId
+      source
+      managedExternally
+      linkedExternally
+      status
+      stale
+      exactAccountId
+      exactAccountCode
+      conditionCode
+      conditionDescription
+      summary
+      classification
+      paymentDays
+      paymentEndOfMonths
+      paymentMethod
+      percentage
+      discountPaymentDays
+      discountPercentage
+      paymentDiscountType
+      syncedAt
+      lastCheckedAt
+      error
+    }
+  }
+`;
+export const EXACT_ONLINE_CUSTOMER_DELIVERY_TERMS_QUERY = /* GraphQL */ `
+  query ExactOnlineCustomerDeliveryTerms($customerId: ID!) {
+    exactOnlineCustomerDeliveryTerms(customerId: $customerId) {
+      customerId
+      source
+      managedExternally
+      linkedExternally
+      status
+      shippingMethodStatus
+      policyStatus
+      summary
+      exactAccountId
+      exactAccountCode
+      preferredShippingMethodId
+      preferredShippingMethodCode
+      preferredShippingMethodName
+      preferredShippingMethodAvailable
+      eligibleShippingMethodIds
+      incotermStatus
+      incotermCode
+      incotermVersion
+      incotermAddress
+      incotermDescription
+      shippingLeadDays
+      deliveryAdvice
+      stale
+      syncedAt
+      lastCheckedAt
+      error
+    }
+  }
+`;
+export const EXACT_ONLINE_CUSTOMER_PRICE_LIST_QUERY = /* GraphQL */ `
+  query ExactOnlineCustomerPriceList($customerId: ID!) {
+    exactOnlineCustomerPriceList(customerId: $customerId) {
+      customerId
+      exactAccountId
+      exactAccountCode
+      exactPriceListId
+      groupId
+      groupName
+      priceListId
+      priceListName
+      status
+      lastReconciledAt
+      lastError
+    }
+  }
+`;
+export const EXACT_ONLINE_ORDER_STATE_QUERY = /* GraphQL */ `
+  query ExactOnlineOrderState($orderId: ID!) {
+    exactOnlineOrderState(orderId: $orderId) {
+      pushed
+      origin
+      salesOrderId
+      salesOrderNumber
+      pushedAt
+      hasCustomer
+      customerLinked
+      unmappedSkus
+      warnings
+    }
+  }
+`;
+export const EXACT_ONLINE_ORDER_SYNC_STATE_QUERY = /* GraphQL */ `
+  query ExactOnlineOrderSyncState($orderId: ID!) {
+    exactOnlineOrderSyncState(orderId: $orderId) {
+      exactSalesOrderId
+      exactOrderNumber
+      revision
+      lastSyncedAt
+      driftDetected
+      exactDeletedAt
+      unmappedSkus
+    }
+  }
+`;
+export const PUSH_ORDER_TO_EXACT_ONLINE_MUTATION = /* GraphQL */ `
+  mutation PushOrderToExactOnline($orderId: ID!) {
+    pushOrderToExactOnline(orderId: $orderId) {
+      success
+      alreadyPushed
+      salesOrderId
+      salesOrderNumber
+      error
+      errorCode
+      warnings
+    }
+  }
+`;
+/**
+ * {@link EXACT_ONLINE_ORDER_STATE_QUERY} without `warnings`, for an engine that predates the field
+ * (#1925): services deploy separately, and GraphQL refuses the whole document over one unknown
+ * field. Drop it once every engine serves `warnings` (orchestrator probe 2026-10-16: production
+ * did not yet).
+ */
+export const EXACT_ONLINE_ORDER_STATE_LEGACY_QUERY = /* GraphQL */ `
+  query ExactOnlineOrderState($orderId: ID!) {
+    exactOnlineOrderState(orderId: $orderId) {
+      pushed
+      origin
+      salesOrderId
+      salesOrderNumber
+      pushedAt
+      hasCustomer
+      customerLinked
+      unmappedSkus
+    }
+  }
+`;
+/**
+ * {@link PUSH_ORDER_TO_EXACT_ONLINE_MUTATION} without `warnings`, for an engine that predates the
+ * field. Safe to send after the current document was refused: an unknown field fails validation,
+ * before the push runs, so nothing reached Exact. Drop it with the state read's.
+ */
+export const PUSH_ORDER_TO_EXACT_ONLINE_LEGACY_MUTATION = /* GraphQL */ `
+  mutation PushOrderToExactOnline($orderId: ID!) {
+    pushOrderToExactOnline(orderId: $orderId) {
+      success
+      alreadyPushed
+      salesOrderId
+      salesOrderNumber
+      error
+      errorCode
+    }
+  }
+`;
+export const REPRICE_EXACT_ONLINE_ORDER_MUTATION = /* GraphQL */ `
+  mutation RepriceExactOnlineOrder($orderId: ID!) {
+    repriceExactOnlineOrder(orderId: $orderId) {
+      success
+      changed
+      linesRepriced
+      error
+    }
+  }
+`;
+export const REPRICE_ALL_EXACT_ONLINE_IMPORTED_ORDERS_MUTATION = /* GraphQL */ `
+  mutation RepriceAllExactOnlineImportedOrders {
+    repriceAllExactOnlineImportedOrders {
+      total
+      repriced
+      skipped
+      failed
+    }
+  }
+`;
+export const RUN_EXACT_ONLINE_ORDER_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineOrderSync {
+    runExactOnlineOrderSync
+  }
+`;
+export const RUN_EXACT_ONLINE_ORDER_BACKFILL_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineOrderBackfill {
+    runExactOnlineOrderBackfill
+  }
+`;
+export const EXACT_PRODUCT_STATUS_QUERY = /* GraphQL */ `
+  query ExactProductStatus($id: ID!) {
+    product(id: $id) {
+      id
+      customFields {
+        exactManaged
+        exactItemId
+        exactItemGroupId
+        exactDisabledReason
+      }
+    }
+  }
+`;
+/** The plugins service's Exact connection-log routes (force-scoped to the caller's store). */
+const CONNECTION_LOGS = '/exact-online/logs';
+/** How long a connection-log export may stream before the call gives up, unless said otherwise. */
+export const EXACT_ONLINE_LOG_EXPORT_TIMEOUT_MS = 120_000;
+const CONNECTION_LOG_KINDS = ['calls', 'events'];
+const invalidInput = (message, field) => new ValidationError({
+    code: 'INVALID_EXACT_ONLINE_INPUT',
+    message,
+    status: 400,
+    service: 'vendure',
+    ...(field ? { details: [{ field, code: 'INVALID_EXACT_ONLINE_INPUT', message }] } : {}),
+});
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function requireObject(value, method) {
+    if (!isObject(value))
+        throw invalidInput(`${method} takes an input object.`);
+    return value;
+}
+/**
+ * The input as the mutation's variables, as given: a key left out stays out, so the engine keeps
+ * the stored value. A key the engine has no argument for is refused here: GraphQL ignores a
+ * variable the operation does not declare, so it would otherwise be dropped silently.
+ */
+function configVariables(input) {
+    const variables = requireObject(input, 'config.update');
+    for (const key of Object.keys(variables)) {
+        if (!Object.hasOwn(EXACT_ONLINE_CONFIG_ARGUMENTS, key)) {
+            throw invalidInput(`${key} is not an Exact Online setting.`, key);
+        }
+    }
+    for (const key of NEVER_NULL_CONFIG_KEYS) {
+        if (Object.hasOwn(variables, key) && variables[key] === null) {
+            throw invalidInput(`${key} cannot be null: leave it out to keep the stored value.`, key);
+        }
+    }
+    return variables;
+}
+/** A sync-log read's variables: only what was given, after the checks the engine would skip. */
+function syncLogVariables(options) {
+    const { entity, limit } = options;
+    if (limit !== undefined &&
+        (!Number.isInteger(limit) || limit < 1 || limit > EXACT_ONLINE_SYNC_LOG_LIMIT)) {
+        throw invalidInput(`limit must be a whole number from 1 to ${String(EXACT_ONLINE_SYNC_LOG_LIMIT)}.`, 'limit');
+    }
+    if (entity !== undefined && (typeof entity !== 'string' || entity.trim() === '')) {
+        throw invalidInput('entity must name a sync entity, such as "items".', 'entity');
+    }
+    return {
+        ...(limit === undefined ? {} : { limit }),
+        ...(entity === undefined ? {} : { entity }),
+    };
+}
+/** An id the call is about, refused before sending when it is not a non-blank string. */
+function requireId(id, field, method) {
+    if (typeof id !== 'string' || id.trim() === '') {
+        throw invalidInput(`${method} needs the ${field}.`, field);
+    }
+    return id;
+}
+function requireEntity(entity) {
+    if (typeof entity !== 'string' || entity.trim() === '') {
+        throw invalidInput('resetCursor needs the entity stream whose cursor to drop.', 'entity');
+    }
+    return entity;
+}
+/**
+ * A connection-log filter as the route's query. The wire cursor is `?before=` (the rows run
+ * newest first); the SDK's name for "the cursor the previous page handed me" is `after`, as on
+ * every list. An undefined value is left out of the query.
+ */
+function connectionLogQuery(filter) {
+    return {
+        before: filter.after,
+        limit: filter.limit,
+        category: filter.category,
+        outcome: filter.outcome,
+        status_code: filter.statusCode,
+        q: filter.q,
+        date_from: filter.dateFrom,
+        date_to: filter.dateTo,
+    };
+}
+/** The per-call options of a filter object (`signal`, `tenant`, `idempotencyKey`). */
+function callOf(filter) {
+    if (!filter)
+        return {};
+    const { signal, tenant, idempotencyKey } = filter;
+    return {
+        ...(signal === undefined ? {} : { signal }),
+        ...(tenant === undefined ? {} : { tenant }),
+        ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
+    };
+}
+export function createExactOnlineModule(transport) {
+    const read = (document, field, options, variables = {}) => fieldOf(transport, document, field, variables, options);
+    async function connectionLogCalls(filter) {
+        const body = await transport.rest('plugins', { method: 'GET', path: `${CONNECTION_LOGS}/calls`, query: connectionLogQuery(filter ?? {}) }, { ...callOf(filter), preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => connectionLogCalls({ ...filter, after: cursor }));
+    }
+    async function connectionLogEvents(filter) {
+        const body = await transport.rest('plugins', { method: 'GET', path: `${CONNECTION_LOGS}/events`, query: connectionLogQuery(filter ?? {}) }, { ...callOf(filter), preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => connectionLogEvents({ ...filter, after: cursor }));
+    }
+    return {
+        config: {
+            async get(options) {
+                return ((await read(EXACT_ONLINE_CONFIG_QUERY, 'exactOnlineConfig', options)) ?? null);
+            },
+            async update(input, options) {
+                return read(UPDATE_EXACT_ONLINE_CONFIG_MUTATION, 'updateExactOnlineConfig', options, configVariables(input));
+            },
+        },
+        credentials: {
+            async set(input, options) {
+                const { clientId, clientSecret, webhookSecret } = requireObject(input, 'credentials.set');
+                if (typeof clientId !== 'string') {
+                    throw invalidInput('credentials.set needs the Exact app client id.', 'clientId');
+                }
+                return read(SET_EXACT_ONLINE_CREDENTIALS_MUTATION, 'setExactOnlineCredentials', options, { clientId, clientSecret, webhookSecret });
+            },
+        },
+        authorizationUrl(region, options) {
+            return read(EXACT_ONLINE_AUTHORIZATION_URL_MUTATION, 'exactOnlineAuthorizationUrl', options, region === undefined ? {} : { region });
+        },
+        async disconnect(options) {
+            return ((await read(DISCONNECT_EXACT_ONLINE_MUTATION, 'disconnectExactOnline', options)) === true);
+        },
+        samples: {
+            accounts(options) {
+                const { limit, ...call } = options ?? {};
+                return read(EXACT_ONLINE_SAMPLE_ACCOUNTS_QUERY, 'exactOnlineSampleAccounts', call, limit === undefined ? {} : { limit });
+            },
+            items(options) {
+                const { limit, ...call } = options ?? {};
+                return read(EXACT_ONLINE_SAMPLE_ITEMS_QUERY, 'exactOnlineSampleItems', call, limit === undefined ? {} : { limit });
+            },
+        },
+        structure: {
+            catalogue(options) {
+                const { sample, ...call } = options ?? {};
+                return read(EXACT_ONLINE_CATALOGUE_STRUCTURE_QUERY, 'exactOnlineCatalogueStructure', call, sample === undefined ? {} : { sample });
+            },
+            customers(options) {
+                const { sample, ...call } = options ?? {};
+                return read(EXACT_ONLINE_CUSTOMER_STRUCTURE_QUERY, 'exactOnlineCustomerStructure', call, sample === undefined ? {} : { sample });
+            },
+            pricing(options) {
+                return read(EXACT_ONLINE_PRICING_STRUCTURE_QUERY, 'exactOnlinePricingStructure', options);
+            },
+        },
+        webhooks: {
+            status(options) {
+                return read(EXACT_ONLINE_WEBHOOK_STATUS_QUERY, 'exactOnlineWebhookStatus', options);
+            },
+            async sync(options) {
+                return ((await read(SYNC_EXACT_ONLINE_WEBHOOKS_MUTATION, 'syncExactOnlineWebhooks', options)) === true);
+            },
+        },
+        async syncEstimate(schedule, options) {
+            return read(EXACT_ONLINE_SYNC_ESTIMATE_QUERY, 'exactOnlineSyncEstimate', options, { schedule: requireObject(schedule, 'syncEstimate') });
+        },
+        sync: {
+            async logs(options) {
+                const { entity, limit, ...call } = options ?? {};
+                return read(EXACT_ONLINE_SYNC_LOGS_QUERY, 'exactOnlineSyncLogs', call, syncLogVariables({ entity, limit }));
+            },
+            health(options) {
+                return read(EXACT_ONLINE_SYNC_HEALTH_QUERY, 'exactOnlineSyncHealth', options);
+            },
+            async runCatalogue(options) {
+                return ((await read(RUN_EXACT_ONLINE_CATALOGUE_SYNC_MUTATION, 'runExactOnlineCatalogueSync', options)) === true);
+            },
+            async runCustomers(options) {
+                return ((await read(RUN_EXACT_ONLINE_CUSTOMER_SYNC_MUTATION, 'runExactOnlineCustomerSync', options)) === true);
+            },
+            async runPriceLists(options) {
+                return ((await read(RUN_EXACT_ONLINE_PRICE_LIST_SYNC_MUTATION, 'runExactOnlinePriceListSync', options)) === true);
+            },
+            reimportPictures(options) {
+                return read(REIMPORT_EXACT_ONLINE_ITEM_PICTURES_MUTATION, 'reimportExactOnlineItemPictures', options);
+            },
+            cursors(options) {
+                return read(EXACT_ONLINE_SYNC_CURSORS_QUERY, 'exactOnlineSyncCursors', options);
+            },
+            async resetCursor(entity, options) {
+                return ((await read(RESET_EXACT_ONLINE_SYNC_CURSOR_MUTATION, 'resetExactOnlineSyncCursor', options, { entity: requireEntity(entity) })) === true);
+            },
+        },
+        warehouseLinks(options) {
+            return read(EXACT_ONLINE_WAREHOUSE_LINKS_QUERY, 'exactOnlineWarehouseLinks', options);
+        },
+        shipping: {
+            methods(options) {
+                return read(EXACT_ONLINE_SHIPPING_METHODS_QUERY, 'exactOnlineShippingMethods', options);
+            },
+            async runSync(options) {
+                return ((await read(RUN_EXACT_ONLINE_SHIPPING_METHOD_SYNC_MUTATION, 'runExactOnlineShippingMethodSync', options)) === true);
+            },
+            import(exactShippingMethodId, options) {
+                return read(IMPORT_EXACT_ONLINE_SHIPPING_METHOD_MUTATION, 'importExactOnlineShippingMethod', options, { exactShippingMethodId });
+            },
+            async setMapping(input, options) {
+                const { vendureShippingMethodId, exactShippingMethodId } = requireObject(input, 'shipping.setMapping');
+                // GraphQL reads a missing argument as null, and the engine trims a blank id to null: a
+                // forgotten key or an emptied field would CLEAR the mapping. Only `null` clears.
+                if (exactShippingMethodId !== null &&
+                    (typeof exactShippingMethodId !== 'string' || exactShippingMethodId.trim() === '')) {
+                    throw invalidInput('shipping.setMapping needs exactShippingMethodId: an Exact method, or null to clear the mapping.', 'exactShippingMethodId');
+                }
+                return read(SET_EXACT_ONLINE_SHIPPING_METHOD_MAPPING_MUTATION, 'setExactOnlineShippingMethodMapping', options, { vendureShippingMethodId, exactShippingMethodId });
+            },
+            async convertToMapping(input, options) {
+                const { exactShippingMethodId, vendureShippingMethodId } = requireObject(input, 'shipping.convertToMapping');
+                return read(CONVERT_EXACT_ONLINE_SHIPPING_METHOD_TO_MAPPING_MUTATION, 'convertExactOnlineShippingMethodToMapping', options, { exactShippingMethodId, vendureShippingMethodId });
+            },
+            async retireImported(exactShippingMethodId, options) {
+                return ((await read(RETIRE_EXACT_ONLINE_IMPORTED_SHIPPING_METHOD_MUTATION, 'retireExactOnlineImportedShippingMethod', options, { exactShippingMethodId })) === true);
+            },
+        },
+        terms: {
+            paymentConditions(options) {
+                return read(EXACT_ONLINE_PAYMENT_CONDITIONS_QUERY, 'exactOnlinePaymentConditions', options);
+            },
+            paymentDiagnostics(options) {
+                return read(EXACT_ONLINE_PAYMENT_TERMS_DIAGNOSTICS_QUERY, 'exactOnlinePaymentTermsDiagnostics', options);
+            },
+            paymentDryRun(options) {
+                return read(EXACT_ONLINE_PAYMENT_TERMS_DRY_RUN_QUERY, 'exactOnlinePaymentTermsDryRun', options);
+            },
+            incoterms(options) {
+                return read(EXACT_ONLINE_INCOTERMS_QUERY, 'exactOnlineIncoterms', options);
+            },
+            deliveryDiagnostics(options) {
+                return read(EXACT_ONLINE_DELIVERY_TERMS_DIAGNOSTICS_QUERY, 'exactOnlineDeliveryTermsDiagnostics', options);
+            },
+            deliveryDryRun(options) {
+                return read(EXACT_ONLINE_DELIVERY_TERMS_DRY_RUN_QUERY, 'exactOnlineDeliveryTermsDryRun', options);
+            },
+        },
+        customers: {
+            async paymentTerms(customerId, options) {
+                return ((await read(EXACT_ONLINE_CUSTOMER_PAYMENT_TERMS_QUERY, 'exactOnlineCustomerPaymentTerms', options, { customerId: requireId(customerId, 'customerId', 'customers.paymentTerms') })) ?? null);
+            },
+            async deliveryTerms(customerId, options) {
+                return ((await read(EXACT_ONLINE_CUSTOMER_DELIVERY_TERMS_QUERY, 'exactOnlineCustomerDeliveryTerms', options, { customerId: requireId(customerId, 'customerId', 'customers.deliveryTerms') })) ?? null);
+            },
+            async priceList(customerId, options) {
+                return read(EXACT_ONLINE_CUSTOMER_PRICE_LIST_QUERY, 'exactOnlineCustomerPriceList', options, { customerId: requireId(customerId, 'customerId', 'customers.priceList') });
+            },
+        },
+        orders: {
+            async state(orderId, options) {
+                const variables = { orderId: requireId(orderId, 'orderId', 'orders.state') };
+                try {
+                    return await read(EXACT_ONLINE_ORDER_STATE_QUERY, 'exactOnlineOrderState', options, variables);
+                }
+                catch (error) {
+                    if (!isUnknownFieldRejection(error))
+                        throw error;
+                    const state = await read(EXACT_ONLINE_ORDER_STATE_LEGACY_QUERY, 'exactOnlineOrderState', options, variables);
+                    return { ...state, warnings: [] };
+                }
+            },
+            async syncState(orderId, options) {
+                return ((await read(EXACT_ONLINE_ORDER_SYNC_STATE_QUERY, 'exactOnlineOrderSyncState', options, { orderId: requireId(orderId, 'orderId', 'orders.syncState') })) ?? null);
+            },
+            async push(orderId, options) {
+                const variables = { orderId: requireId(orderId, 'orderId', 'orders.push') };
+                try {
+                    return await read(PUSH_ORDER_TO_EXACT_ONLINE_MUTATION, 'pushOrderToExactOnline', options, variables);
+                }
+                catch (error) {
+                    // Only a document the engine refused before running it is sent again (see the legacy
+                    // mutation's comment): any other failure may have reached Exact and is thrown as is.
+                    if (!isUnknownFieldRejection(error))
+                        throw error;
+                    const result = await read(PUSH_ORDER_TO_EXACT_ONLINE_LEGACY_MUTATION, 'pushOrderToExactOnline', options, variables);
+                    return { ...result, warnings: null };
+                }
+            },
+            async reprice(orderId, options) {
+                return read(REPRICE_EXACT_ONLINE_ORDER_MUTATION, 'repriceExactOnlineOrder', options, { orderId: requireId(orderId, 'orderId', 'orders.reprice') });
+            },
+            repriceAll(options) {
+                return read(REPRICE_ALL_EXACT_ONLINE_IMPORTED_ORDERS_MUTATION, 'repriceAllExactOnlineImportedOrders', options);
+            },
+            async runSync(options) {
+                return ((await read(RUN_EXACT_ONLINE_ORDER_SYNC_MUTATION, 'runExactOnlineOrderSync', options)) === true);
+            },
+            async runBackfill(options) {
+                return ((await read(RUN_EXACT_ONLINE_ORDER_BACKFILL_MUTATION, 'runExactOnlineOrderBackfill', options)) === true);
+            },
+        },
+        products: {
+            async status(productId, options) {
+                const product = await read(EXACT_PRODUCT_STATUS_QUERY, 'product', options, { id: requireId(productId, 'productId', 'products.status') });
+                if (!product)
+                    return null;
+                const fields = product.customFields;
+                return {
+                    exactManaged: fields?.exactManaged ?? null,
+                    exactItemId: fields?.exactItemId ?? null,
+                    exactItemGroupId: fields?.exactItemGroupId ?? null,
+                    exactDisabledReason: fields?.exactDisabledReason ?? null,
+                };
+            },
+        },
+        connectionLogs: {
+            calls: connectionLogCalls,
+            events: connectionLogEvents,
+            async export(kind, filter, options) {
+                if (!CONNECTION_LOG_KINDS.includes(kind)) {
+                    throw invalidInput('kind must be "calls" or "events".', 'kind');
+                }
+                // A CSV body, never JSON: `blob` keeps the transport from parsing or case-converting it.
+                const answer = await transport.rest('plugins', {
+                    method: 'GET',
+                    path: `${CONNECTION_LOGS}/${kind}/export`,
+                    query: connectionLogQuery(requireObject(filter, 'connectionLogs.export')),
+                    expect: 'blob',
+                }, { timeoutMs: EXACT_ONLINE_LOG_EXPORT_TIMEOUT_MS, ...options });
+                return answer.blob.text();
+            },
+        },
+    };
+}