@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/integrations/exact-online-types.d.ts

@@ -0,0 +1,965 @@
+/**
+ * The shapes of `admin.integrations.exactOnline` (headless W10-55): the store's Exact Online
+ * connection, its settings, the read-only structure probes of the connected division, and the
+ * calls-per-day estimate of a sync schedule.
+ */
+/** When an order auto-pushes to Exact, by lifecycle event (`off`: never). */
+export type ExactAutoPushTrigger = 'off' | 'placed' | 'paid' | 'fulfilled';
+export interface ExactAutoPushRule {
+    customerGroupId: string;
+    trigger: ExactAutoPushTrigger;
+}
+/** The store's automatic order push, per customer group: the first rule naming a group wins. */
+export interface ExactAutoPushConfig {
+    /** Master switch: off, nothing auto-pushes whatever the rules say. */
+    enabled: boolean;
+    /** The trigger of a customer no rule names. */
+    defaultTrigger: ExactAutoPushTrigger;
+    rules: ExactAutoPushRule[];
+}
+/** Inbound account filter: sales accounts only, or every account. */
+export type ExactCustomerAccountFilter = 'sales' | 'all';
+/** Which side wins when a customer differs between Exact and the platform. */
+export type ExactCustomerOverwritePolicy = 'exact-authoritative' | 'last-writer-wins';
+/** The store's customer sync, both ways. */
+export interface ExactCustomerSyncConfig {
+    /** Master switch: off, neither direction runs. */
+    enabled: boolean;
+    /** Inbound: an Accounts webhook from Exact starts a customer sync. */
+    webhookEnabled: boolean;
+    /** Outbound: a customer edited here is pushed to its Exact Account. */
+    pushEnabled: boolean;
+    accountFilter: ExactCustomerAccountFilter;
+    overwritePolicy: ExactCustomerOverwritePolicy;
+    /** The outbound fields. */
+    fields: {
+        name: boolean;
+        email: boolean;
+        address: boolean;
+    };
+}
+/** A payment method of the store, mapped to the Exact condition orders paid with it carry. */
+export interface ExactPaymentMethodCondition {
+    paymentMethodId: string;
+    conditionCode: string;
+}
+/** Exact-owned customer payment terms. */
+export interface ExactPaymentTermsConfig {
+    /** The mirrored Exact condition is authoritative for checkout and pay-on-account orders. */
+    enabled: boolean;
+    /** Mirror Exact's conditions and assignments, without changing checkout or orders. */
+    synchronizationEnabled: boolean;
+    /** The condition a brand-new Account the platform creates in Exact gets; never an existing one. */
+    newAccountPaymentConditionCode: string | null;
+    /** Prepaid payment-method overrides, applied when an order's terms are captured. */
+    paymentMethodConditions: ExactPaymentMethodCondition[];
+}
+/** Exact-owned customer delivery profiles. */
+export interface ExactDeliveryTermsConfig {
+    enabled: boolean;
+    synchronizationEnabled: boolean;
+    /** Send the buyer's requested delivery day to Exact as the sales order's delivery date. */
+    forwardRequestedDeliveryDate: boolean;
+    /**
+     * Send where a pushed order ships as the sales order's delivery address. Optional here because
+     * a save that leaves it out keeps the stored switch; every read carries it.
+     */
+    sendDeliveryAddress?: boolean;
+    /** The defaults below seed only a brand-new Account the platform creates in Exact. */
+    newAccountShippingMethodId: string | null;
+    newAccountIncotermCode: string | null;
+    newAccountIncotermVersion: number | null;
+    newAccountIncotermAddress: string | null;
+    /** Dispatch lead time in days, not a promised arrival. Zero is valid. */
+    newAccountShippingLeadDays: number | null;
+    /** Exact's DeliveryAdvice: 0 partial, 1 complete, 2 partial without backorder. */
+    newAccountDeliveryAdvice: 0 | 1 | 2 | null;
+}
+/** One scheduled sweep: whether it runs, and the minutes between runs. */
+export interface ExactSyncWindow {
+    enabled: boolean;
+    intervalMinutes: number;
+}
+/** The store's scheduled Exact → platform sweeps, and the advisory daily call budget. */
+export interface ExactSyncSchedule {
+    /** Near-real-time price delta. */
+    delta: ExactSyncWindow;
+    /** Items, stock, warehouses, shipping methods and pictures: the full reconciler. */
+    full: ExactSyncWindow;
+    /** Inbound sales orders. */
+    order: ExactSyncWindow;
+    /** Inbound purchase orders, feeding incoming stock (storefront restock dates). */
+    purchaseOrders: ExactSyncWindow;
+    /** Prunes incoming stock of purchase orders deleted in Exact (the sweep above never sees one). */
+    purchaseOrdersReconcile: ExactSyncWindow;
+    /** Accounts and their payment conditions. */
+    customers: ExactSyncWindow;
+    /** B2B price agreements and named price lists: the integration's heaviest reads. */
+    priceLists: ExactSyncWindow;
+    /** Advisory only (0: none set); see {@link ExactSyncEstimate.overBudget}. */
+    dailyCallBudget: number;
+}
+/**
+ * A schedule to save or estimate. `delta`, `full`, `order` and the budget are always sent; a
+ * window left out keeps the stored one, an explicit `null` window its default.
+ */
+export interface ExactSyncScheduleInput {
+    delta: ExactSyncWindow;
+    full: ExactSyncWindow;
+    order: ExactSyncWindow;
+    purchaseOrders?: ExactSyncWindow | null;
+    purchaseOrdersReconcile?: ExactSyncWindow | null;
+    customers?: ExactSyncWindow | null;
+    priceLists?: ExactSyncWindow | null;
+    dailyCallBudget: number;
+}
+/** What the catalogue import does with an Exact item that is not a stock item. */
+export type ExactNonStockItemPolicy = 'public' | 'disabled' | 'skip';
+/** What the catalogue import does with an Exact item with no usable sales price. */
+export type ExactUnpricedItemPolicy = 'import' | 'disabled';
+/** The tax basis Exact's prices arrive in: as the store keeps them, net or gross. */
+export type ExactPriceBasis = 'channel' | 'net' | 'gross';
+/** Whether, and how, Exact item pictures become product images. */
+export type ExactPicturePolicy = 'off' | 'fill_missing' | 'exact_owns_featured';
+/** Which Exact stock figure becomes on-hand: In stock, or Free stock (minus reserved). */
+export type ExactStockBasis = 'in_stock' | 'free_stock';
+/**
+ * Which Exact items may become publicly visible storefront products. Every read carries the
+ * RESOLVED policy: a store that never saved one reads the engine's defaults.
+ */
+export interface ExactCatalogueImportPolicy {
+    /** Import only items whose Exact `IsWebshopItem` flag is set. */
+    requireWebshopFlag: boolean;
+    nonStockItems: ExactNonStockItemPolicy;
+    unpricedItems: ExactUnpricedItemPolicy;
+    priceBasis: ExactPriceBasis;
+    pictures: ExactPicturePolicy;
+    stockBasis: ExactStockBasis;
+}
+/**
+ * A catalogue-policy change, MERGED over the stored policy: a key left out keeps its value, an
+ * explicit `null` resets it to the default. Send only the keys that changed.
+ */
+export interface ExactCatalogueImportPolicyInput {
+    requireWebshopFlag?: boolean | null;
+    nonStockItems?: ExactNonStockItemPolicy | null;
+    unpricedItems?: ExactUnpricedItemPolicy | null;
+    priceBasis?: ExactPriceBasis | null;
+    pictures?: ExactPicturePolicy | null;
+    stockBasis?: ExactStockBasis | null;
+}
+/**
+ * The store's Exact Online connection and settings. The client secret, the webhook secret and
+ * the OAuth tokens are write-only: no read returns them in any form.
+ */
+export interface ExactOnlineConfig {
+    id: string;
+    /** The integration's runtime switch (the scheduled sweeps and automatic pushes follow it). */
+    enabled: boolean;
+    /** An Exact division is connected (OAuth) and its refresh token is held. */
+    connected: boolean;
+    /** Where the Exact administration lives: `nl`, `be`, `de`, `uk`, `fr`, `es` or `com`. */
+    region: string;
+    division: string | null;
+    companyName: string | null;
+    /** The store's own Exact app client id. */
+    clientId: string | null;
+    /** The store has stored its Exact app's client id AND secret: it can connect. */
+    hasCustomCredentials: boolean;
+    hasWebhookSecret: boolean;
+    lastConnectedAt: string | null;
+    lastRefreshedAt: string | null;
+    accessTokenExpiresAt: string | null;
+    /** The Exact item the shipping-cost line of a pushed sales order is booked on. */
+    shippingItemCode: string | null;
+    /** The Exact item a pushed order's promotion discount is booked on; null folds it into prices. */
+    discountItemCode: string | null;
+    /** The Exact item externally priced order lines are booked on. */
+    externalLineItemCode: string | null;
+    /** A pushed sales order carries the order's surcharges, one line each. */
+    pushSurcharges: boolean;
+    surchargeItemCode: string | null;
+    negativeSurchargeItemCode: string | null;
+    /** Advice (never a refusal) when surcharges push while auto-push sends orders early. */
+    pushSurchargesWarning: string | null;
+    autoPush: ExactAutoPushConfig;
+    customerSync: ExactCustomerSyncConfig;
+    paymentTerms: ExactPaymentTermsConfig;
+    deliveryTerms: ExactDeliveryTermsConfig;
+    syncSchedule: ExactSyncSchedule;
+    catalogueImportPolicy: ExactCatalogueImportPolicy;
+    /** When each sweep was last QUEUED (null: never); how it ended is in the sync log. */
+    deltaLastEnqueuedAt: string | null;
+    fullLastEnqueuedAt: string | null;
+    orderLastEnqueuedAt: string | null;
+    purchaseOrderLastEnqueuedAt: string | null;
+    purchaseOrderReconcileLastEnqueuedAt: string | null;
+    customerLastEnqueuedAt: string | null;
+    priceListLastEnqueuedAt: string | null;
+}
+/** A payment-terms section to save; `paymentMethodConditions` left out keeps the stored list. */
+export interface ExactPaymentTermsConfigInput {
+    enabled: boolean;
+    synchronizationEnabled?: boolean | null;
+    newAccountPaymentConditionCode?: string | null;
+    paymentMethodConditions?: ExactPaymentMethodCondition[] | null;
+}
+/** A delivery-terms section to save; `sendDeliveryAddress` left out keeps the stored switch. */
+export interface ExactDeliveryTermsConfigInput {
+    enabled: boolean;
+    synchronizationEnabled?: boolean | null;
+    forwardRequestedDeliveryDate?: boolean | null;
+    sendDeliveryAddress?: boolean | null;
+    newAccountShippingMethodId?: string | null;
+    newAccountIncotermCode?: string | null;
+    newAccountIncotermVersion?: number | null;
+    newAccountIncotermAddress?: string | null;
+    newAccountShippingLeadDays?: number | null;
+    newAccountDeliveryAdvice?: number | null;
+}
+/**
+ * A settings change: every key optional, a key left out keeps the stored value. `autoPush` and
+ * `customerSync` replace their whole setting (`null`: the default); `syncSchedule` and
+ * `catalogueImportPolicy` merge over the stored one. The OAuth connection and the app
+ * credentials have their own methods.
+ *
+ * `region`, `enabled`, `shippingItemCode`, `discountItemCode`, `paymentTerms` and `deliveryTerms`
+ * take no `null` (the engine cannot store one): the SDK refuses it before sending.
+ */
+export interface UpdateExactOnlineConfigInput {
+    region?: string;
+    enabled?: boolean;
+    /** Trimmed; blank clears it. */
+    shippingItemCode?: string;
+    /** Trimmed; blank clears it, folding promotions back into the line prices. */
+    discountItemCode?: string;
+    /** Trimmed; blank or `null` clears it; over 60 characters is refused `USER_INPUT_ERROR`. */
+    externalLineItemCode?: string | null;
+    /** `null` restores the default, off. */
+    pushSurcharges?: boolean | null;
+    /** Trimmed; blank or `null` clears it; over 60 characters is refused `USER_INPUT_ERROR`. */
+    surchargeItemCode?: string | null;
+    /** Trimmed; blank or `null` clears it; over 60 characters is refused `USER_INPUT_ERROR`. */
+    negativeSurchargeItemCode?: string | null;
+    autoPush?: ExactAutoPushConfig | null;
+    customerSync?: ExactCustomerSyncConfig | null;
+    paymentTerms?: ExactPaymentTermsConfigInput;
+    deliveryTerms?: ExactDeliveryTermsConfigInput;
+    syncSchedule?: ExactSyncScheduleInput | null;
+    catalogueImportPolicy?: ExactCatalogueImportPolicyInput | null;
+}
+/** The store's own Exact app, entered before connecting. */
+export interface SetExactOnlineCredentialsInput {
+    clientId: string;
+    /** Write-only. Left out, or blank, the stored secret stays. */
+    clientSecret?: string | null;
+    /** Write-only. Left out, or blank, the stored secret stays. */
+    webhookSecret?: string | null;
+}
+/** One CRM Account of the connected division, read live. */
+export interface ExactOnlineAccountPreview {
+    id: string;
+    code: string | null;
+    name: string | null;
+    city: string | null;
+    country: string | null;
+    email: string | null;
+    status: string | null;
+}
+/** One logistics Item of the connected division, read live. */
+export interface ExactOnlineItemPreview {
+    id: string;
+    code: string | null;
+    description: string | null;
+    isSalesItem: boolean | null;
+    isStockItem: boolean | null;
+}
+export interface ExactItemGroupStat {
+    code: string | null;
+    description: string | null;
+    itemCount: number;
+}
+export interface ExactClassFieldStat {
+    field: string;
+    nonEmptyCount: number;
+    distinctCount: number;
+}
+export interface ExactCatalogueRow {
+    code: string | null;
+    description: string | null;
+    itemGroup: string | null;
+}
+/** How the division's items group, for designing the item → product grouping rule. */
+export interface ExactCatalogueStructure {
+    sampledCount: number;
+    distinctItemGroupCount: number;
+    topItemGroups: ExactItemGroupStat[];
+    classFields: ExactClassFieldStat[];
+    rows: ExactCatalogueRow[];
+}
+export interface ExactClassificationValueStat {
+    id: string;
+    code: string | null;
+    description: string | null;
+    accountCount: number;
+}
+export interface ExactClassificationDimension {
+    sequence: number;
+    name: string;
+    slotField: string;
+    populatedCount: number;
+    distinctCount: number;
+    values: ExactClassificationValueStat[];
+}
+export interface ExactPriceListStat {
+    id: string;
+    code: string | null;
+    description: string | null;
+    accountCount: number;
+}
+export interface ExactAccountRow {
+    code: string | null;
+    name: string | null;
+    email: string | null;
+    city: string | null;
+    country: string | null;
+    isReseller: boolean;
+    classifications: string[];
+    priceList: string | null;
+}
+/** How the division's Accounts group, for designing the Account → customer group mapping. */
+export interface ExactAccountStructure {
+    sampledCount: number;
+    withEmail: number;
+    withoutEmail: number;
+    withAddress: number;
+    resellerCount: number;
+    dimensions: ExactClassificationDimension[];
+    priceLists: ExactPriceListStat[];
+    rows: ExactAccountRow[];
+}
+export interface ExactPriceListInfo {
+    id: string;
+    code: string | null;
+    description: string | null;
+    currency: string | null;
+}
+export interface ExactPriceListItemSample {
+    itemCode: string | null;
+    itemDescription: string | null;
+    quantity: number | null;
+    newPrice: number | null;
+    discount: number | null;
+    entryMethod: number | null;
+    /** `set`: the list defines its own base price for the item; `standard`: the item's own. */
+    basePrice: 'set' | 'standard';
+}
+export interface ExactCustomerPriceSample {
+    itemCode: string | null;
+    accountName: string | null;
+    price: number | null;
+    quantity: number | null;
+    currency: string | null;
+}
+/** Named price lists against per-customer item prices in the division. */
+export interface ExactPricingStructure {
+    priceLists: ExactPriceListInfo[];
+    priceListItemPriceCount: number;
+    priceListItemSamples: ExactPriceListItemSample[];
+    accountsWithDefaultPriceList: number;
+    customerPriceCount: number;
+    customerPriceDistinctAccounts: number;
+    customerPriceDistinctItems: number;
+    customerPriceSamples: ExactCustomerPriceSample[];
+    sampled: boolean;
+}
+/** One Exact webhook subscription live for the store. */
+export interface ExactWebhookSubscription {
+    topic: string;
+    subscriptionId: string | null;
+    callbackUrl: string | null;
+}
+/** The store's Exact webhook subscriptions, read live. */
+export interface ExactWebhookStatus {
+    /** A webhook secret is stored: real-time webhooks are possible. */
+    supported: boolean;
+    /** At least one of the platform's subscriptions is live in Exact. */
+    registered: boolean;
+    subscriptions: ExactWebhookSubscription[];
+    /** When this live read ran. */
+    checkedAt: string;
+    /** Set when the live read itself failed; the rest is then a best-effort answer. */
+    error: string | null;
+}
+/** One sweep's share of {@link ExactSyncEstimate}. */
+export interface ExactSyncSweepEstimate {
+    enabled: boolean;
+    /** The interval the estimate used: the one asked for, rounded and clamped (what a save stores). */
+    intervalMinutes: number;
+    minIntervalMinutes: number;
+    maxIntervalMinutes: number;
+    /** Representative Exact calls one run makes; a lower bound for the sweeps that page. */
+    callsPerRun: number;
+    /** Whole runs a day at `intervalMinutes`. */
+    runsPerDay: number;
+    /** `runsPerDay × callsPerRun`; 0 when the sweep is off. */
+    callsPerDay: number;
+}
+/** The Exact API calls a day a sync schedule makes. Advice: nothing is ever capped by it. */
+export interface ExactSyncEstimate {
+    delta: ExactSyncSweepEstimate;
+    full: ExactSyncSweepEstimate;
+    order: ExactSyncSweepEstimate;
+    purchaseOrders: ExactSyncSweepEstimate;
+    purchaseOrdersReconcile: ExactSyncSweepEstimate;
+    customers: ExactSyncSweepEstimate;
+    priceLists: ExactSyncSweepEstimate;
+    /** Every sweep's `callsPerDay`, summed. */
+    total: number;
+    /** The budget as a save stores it; 0 means none is set. */
+    dailyCallBudget: number;
+    /** A budget is set (above 0) and `total` exceeds it. */
+    overBudget: boolean;
+}
+/** Per-reason count of the items one catalogue run kept out of the storefront. */
+export interface ExactCatalogueExclusionCounts {
+    /**
+     * Items outside their Exact active window (end date passed, or start date still ahead). Always
+     * applied, not a policy control; null on rows recorded before the rule existed.
+     */
+    inactive: number | null;
+    /** Items whose Exact webshop flag is off (counted only while `requireWebshopFlag` is on). */
+    notWebshop: number;
+    /** Non-stock items the `nonStockItems` policy kept out. */
+    nonStock: number;
+    /** Items with no usable default-currency sales price the `unpricedItems` policy kept out. */
+    unpriced: number;
+    /** Every excluded item: the reasons above are exclusive and sum to it. `absent` is not in it. */
+    total: number;
+    /**
+     * Items the store holds that the run's Exact read did not return at all (deleted in Exact, or
+     * no longer a sales item), which the run disabled. Null when the reverse pass did not run (the
+     * read could not be proven complete, or the row predates the pass): NOT the same as 0.
+     */
+    absent: number | null;
+}
+/** One run of an inbound (Exact → platform) sync, as the sync log recorded it. */
+export interface ExactOnlineSyncLogEntry {
+    id: string;
+    /** What the run read or wrote: `items`, `prices`, `stock`, `pictures`, `customers`, `orders`, … */
+    entity: string;
+    /** How it started: `seed`, `delta`, `manual`, `scheduled` or `webhook`. */
+    mode: string;
+    /** `success`, `partial` or `failed`; any other value is a warning. */
+    status: string;
+    createdCount: number;
+    updatedCount: number;
+    skippedCount: number;
+    failedCount: number;
+    /** Pictures withdrawn from products by this run; only ever above 0 on `pictures` rows. */
+    detachedCount: number;
+    /** The run's failure in the engine's words (secrets scrubbed); null for a clean run. */
+    error: string | null;
+    durationMs: number | null;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** The catalogue import policy's exclusions; only ever set on `items` rows. */
+    catalogueExclusions: ExactCatalogueExclusionCounts | null;
+}
+/** How the newest real run of one inbound area ended. */
+export interface ExactOnlineSyncRunSummary {
+    /** When that run was logged; for the catalogue, when its sweep started. ISO-8601 UTC. */
+    lastRunAt: string;
+    /** `success`, `partial`, `failed` or `warning`. */
+    status: string;
+    error: string | null;
+    /** When the area last ran clean; null when no clean run is known. */
+    lastSuccessAt: string | null;
+}
+/**
+ * How the newest real run of each inbound area ended, read from the sync log. The schedule's
+ * `*LastEnqueuedAt` times say only that a run was QUEUED, whether or not it then failed. An area
+ * that never ran (or a store that is not connected) is null.
+ */
+export interface ExactOnlineSyncHealth {
+    /** The newest customer synchronization that was not a webhook read of one Account. */
+    customers: ExactOnlineSyncRunSummary | null;
+    /** The newest catalogue sweep (warehouses, items, stock): the worst of its steps. */
+    catalogue: ExactOnlineSyncRunSummary | null;
+    /** The newest inbound order synchronization. */
+    orders: ExactOnlineSyncRunSummary | null;
+}
+/** What {@link ExactOnlineSyncModule.logs} reads. */
+export interface ExactOnlineSyncLogOptions {
+    /** One entity's runs only (`items`, `pictures`, `price-lists`, …); every entity's otherwise. */
+    entity?: string;
+    /** How many of the newest runs: a whole number from 1 to 100; 20 when left out. */
+    limit?: number;
+}
+/** One Exact Sync API cursor (watermark) of the store, by entity stream. */
+export interface ExactSyncCursor {
+    /** The entity stream: `items`, `stock`, `salesOrders`, `accounts`, … */
+    entity: string;
+    /** Opaque; null when the stream never advanced. */
+    cursor: string | null;
+}
+/** A stock location of the store and the Exact warehouse it mirrors (read-only). */
+export interface ExactWarehouseLink {
+    stockLocationId: string;
+    stockLocationName: string;
+    /** The Exact warehouse GUID; null while the location is not linked. */
+    exactWarehouseId: string | null;
+}
+/** A platform shipping method's Exact mapping, live against the store's Exact catalogue. */
+export type ExactShippingMethodStatus = 'mapped' | 'unmapped' | 'exact-missing';
+/** One platform shipping method of the store, joined to its Exact mapping. */
+export interface ExactShippingMethodMapping {
+    vendureShippingMethodId: string;
+    vendureCode: string;
+    vendureName: string;
+    /** The Exact shipping method (GUID) it maps to; null when unmapped. */
+    exactShippingMethodId: string | null;
+    /** Exact created it (Activated) and owns its name and rate; only these convert or retire. */
+    exactManaged: boolean;
+    /** `exact-missing`: the mapped Exact method is no longer active or current in Exact. */
+    status: ExactShippingMethodStatus;
+}
+/** One shipping method of the store's synchronized Exact catalogue. */
+export interface ExactShippingMethodPreview {
+    /** The Exact GUID. */
+    id: string;
+    code: string | null;
+    description: string | null;
+    /** Active in Exact and current in the synchronized catalogue: only these can be activated. */
+    active: boolean;
+    /** Exact's flat rate in major units; null when Exact defines none (never free shipping). */
+    amount: number | null;
+    /** A platform method of the store already maps to it. */
+    linked: boolean;
+}
+/** The store's shipping methods joined to Exact, and its synchronized Exact catalogue. */
+export interface ExactShippingMethodsView {
+    mappings: ExactShippingMethodMapping[];
+    exact: ExactShippingMethodPreview[];
+}
+export interface SetExactShippingMethodMappingInput {
+    /** A shipping method of the store. */
+    vendureShippingMethodId: string;
+    /** The Exact method to map it to; null clears the mapping. */
+    exactShippingMethodId: string | null;
+}
+export interface ConvertExactShippingMethodInput {
+    /** The Activated Exact method whose imported platform method is retired. */
+    exactShippingMethodId: string;
+    /** The store's own platform method (not Exact-managed) the mapping moves to. */
+    vendureShippingMethodId: string;
+}
+/** Which Exact connection log: the API calls, or the sync and lifecycle events. */
+export type ExactOnlineConnectionLogKind = 'calls' | 'events';
+/**
+ * The dates of an Exact connection-log filter: inclusive ISO-8601. Pass an explicit offset
+ * (`2026-10-14T00:00:00+02:00`): the service pins only a bare `dateTo` (`2026-10-14` reads as
+ * the end of that UTC day); any other value without an offset, a bare `dateFrom` included, is
+ * read in the audit database's session time zone.
+ */
+export interface ExactOnlineConnectionLogDates {
+    dateFrom?: string;
+    dateTo?: string;
+}
+/** Filters for {@link ExactOnlineConnectionLogsModule.calls}. */
+export interface ExactOnlineConnectionLogCallFilter extends ExactOnlineConnectionLogDates {
+    /** `succeeded`, `failed` or `timeout`. */
+    outcome?: string;
+    /** The real HTTP status Exact answered. */
+    statusCode?: number;
+    /** Free text over the operation, the error and the remote reference. */
+    q?: string;
+}
+/** Filters for {@link ExactOnlineConnectionLogsModule.events}. */
+export interface ExactOnlineConnectionLogEventFilter extends ExactOnlineConnectionLogDates {
+    /** `admin_action`, `integration`, `job`, `webhook`, `system`, … */
+    category?: string;
+    /** `succeeded`, `failed`, `partial`, `skipped` or `rejected`. */
+    outcome?: string;
+    /** Free text over the action, the target label, the error detail and the actor label. */
+    q?: string;
+}
+/** An export's filter: one log's filters, over a bounded range of at most 366 days. */
+export type ExactOnlineConnectionLogExportFilter = (ExactOnlineConnectionLogCallFilter | ExactOnlineConnectionLogEventFilter) & {
+    dateFrom: string;
+    dateTo: string;
+};
+/** How a mirrored payment condition is due. */
+export type ExactPaymentConditionClassification = 'single_due_date' | 'complex' | 'unresolved' | 'unassigned';
+/** A payment condition mirrored from the connected Exact division. */
+export interface ExactPaymentCondition {
+    exactId: string;
+    code: string;
+    description: string | null;
+    /** The condition in a sentence. */
+    summary: string;
+    classification: ExactPaymentConditionClassification;
+    paymentDays: number | null;
+    paymentEndOfMonths: number | null;
+    paymentMethod: string | null;
+    percentage: number | null;
+    discountPaymentDays: number | null;
+    discountPercentage: number | null;
+    paymentDiscountType: string | null;
+    active: boolean;
+    /** ISO-8601, UTC. */
+    syncedAt: string;
+}
+/** How many customers hold one payment condition. */
+export interface ExactPaymentConditionDistribution {
+    code: string;
+    description: string | null;
+    customerCount: number;
+}
+/** A condition code customers hold that the mirrored catalog does not know. */
+export interface ExactUnresolvedPaymentCondition {
+    code: string;
+    customerCount: number;
+}
+/** How the newest payment-terms reconcile went. */
+export interface ExactPaymentTermsSyncSummary {
+    mode: string;
+    status: string;
+    createdCount: number;
+    updatedCount: number;
+    deactivatedCount: number;
+    failedCount: number;
+    /** ISO-8601, UTC. */
+    at: string;
+    error: string | null;
+}
+/** Coverage and freshness of the Exact Account → payment-condition mirror. */
+export interface ExactPaymentTermsDiagnostics {
+    totalCustomers: number;
+    assignedCount: number;
+    unassignedCount: number;
+    unresolvedCount: number;
+    staleCount: number;
+    lastSyncedAt: string | null;
+    error: string | null;
+    permissionWarning: boolean;
+    distribution: ExactPaymentConditionDistribution[];
+    unresolvedCodes: ExactUnresolvedPaymentCondition[];
+    lastReconciliation: ExactPaymentTermsSyncSummary | null;
+}
+/** One Exact read a dry run made, and whether it worked. */
+export interface ExactTermsDryRunResource {
+    resource: string;
+    ok: boolean;
+    permissionWarning: boolean;
+    error: string | null;
+}
+/** A condition code the dry run found duplicated, or not representable as one due date. */
+export interface ExactPaymentTermsDryRunCondition {
+    code: string;
+    description: string | null;
+    summary: string;
+    classification: 'single_due_date' | 'complex';
+    scheduleCount: number;
+}
+/** An Exact Account whose payment condition the platform could not take over. */
+export interface ExactPaymentTermsDryRunAssignmentIssue {
+    accountId: string;
+    accountCode: string | null;
+    conditionCode: string | null;
+    conditionDescription: string | null;
+    status: 'unassigned' | 'unresolved' | 'unchecked';
+}
+/** A live, read-only reconciliation of the division's payment conditions. */
+export interface ExactPaymentTermsDryRun {
+    division: string;
+    /** ISO-8601, UTC. */
+    generatedAt: string;
+    /** False when a read stopped early: the counts are then a lower bound. */
+    complete: boolean;
+    permissionWarning: boolean;
+    catalogRowCount: number;
+    catalogCodeCount: number;
+    accountCount: number;
+    assignedCount: number;
+    unassignedCount: number;
+    unresolvedCount: number;
+    uncheckedCount: number;
+    distribution: ExactPaymentConditionDistribution[];
+    duplicateConditions: ExactPaymentTermsDryRunCondition[];
+    complexConditions: ExactPaymentTermsDryRunCondition[];
+    unresolvedCodes: ExactUnresolvedPaymentCondition[];
+    assignmentIssues: ExactPaymentTermsDryRunAssignmentIssue[];
+    resources: ExactTermsDryRunResource[];
+}
+/** An Incoterm of the division's mirrored catalog. */
+export interface ExactIncoterm {
+    exactId: number;
+    code: string;
+    version: number;
+    description: string | null;
+    catalogAvailable: boolean;
+    stale: boolean;
+    lastSyncedAt: string | null;
+    error: string | null;
+}
+/**
+ * Whether a customer synchronization has ever mirrored Account delivery assignments on this
+ * division. `never`: the operational switch cannot be saved yet (readiness needs one success).
+ */
+export type ExactDeliveryTermsAccountSyncStatus = 'never' | 'succeeded' | 'failed';
+/** How many customers hold one Exact shipping method. */
+export interface ExactDeliveryTermsShippingDistribution {
+    exactId: string;
+    code: string | null;
+    description: string | null;
+    customerCount: number;
+}
+/** How many customers hold one Incoterm. */
+export interface ExactDeliveryTermsIncotermDistribution {
+    code: string;
+    version: number | null;
+    description: string | null;
+    customerCount: number;
+}
+/** Coverage and freshness of the Exact Account delivery assignments, and the method mapping. */
+export interface ExactDeliveryTermsDiagnostics {
+    reconciliationRequired: boolean;
+    accountSyncStatus: ExactDeliveryTermsAccountSyncStatus;
+    totalCustomers: number;
+    assignedCount: number;
+    unassignedCount: number;
+    unresolvedCount: number;
+    staleCount: number;
+    mappedMethodCount: number;
+    /** Mappings that also pass the operational readiness check (it rejects stale definitions). */
+    usableShippingMappingCount: number;
+    unmappedMethodCount: number;
+    inactiveMethodCount: number;
+    unavailableMethodCount: number;
+    nullAmountCount: number;
+    invalidIncotermCount: number;
+    lastSyncedAt: string | null;
+    error: string | null;
+    permissionWarning: boolean;
+    shippingMethodDistribution: ExactDeliveryTermsShippingDistribution[];
+    incotermDistribution: ExactDeliveryTermsIncotermDistribution[];
+    warnings: string[];
+}
+/** An Exact Account whose delivery assignment the platform could not take over. */
+export interface ExactDeliveryTermsDryRunIssue {
+    accountId: string;
+    accountCode: string | null;
+    shippingMethodId: string | null;
+    incotermCode: string | null;
+    incotermVersion: number | null;
+    status: 'unassigned_shipping' | 'unresolved_shipping' | 'unmapped_shipping' | 'unresolved_incoterm' | 'invalid_policy' | 'unchecked';
+    message: string;
+}
+/** A live, read-only reconciliation of the division's delivery assignments. */
+export interface ExactDeliveryTermsDryRun {
+    division: string;
+    /** ISO-8601, UTC. */
+    generatedAt: string;
+    /** False when a read stopped early: the counts are then a lower bound. */
+    complete: boolean;
+    permissionWarning: boolean;
+    shippingMethodCount: number;
+    activeShippingMethodCount: number;
+    mappingCount: number;
+    unmappedCatalogMethodCount: number;
+    nullAmountCount: number;
+    zeroAmountCount: number;
+    incotermCount: number;
+    accountCount: number;
+    assignedShippingMethodCount: number;
+    mappedAssignedShippingMethodCount: number;
+    unmappedAssignedShippingMethodCount: number;
+    unassignedShippingMethodCount: number;
+    unresolvedShippingMethodCount: number;
+    assignedIncotermCount: number;
+    unassignedIncotermCount: number;
+    unresolvedIncotermCount: number;
+    invalidPolicyCount: number;
+    shippingMethodDistribution: Array<{
+        exactId: string;
+        customerCount: number;
+    }>;
+    incotermDistribution: Array<{
+        code: string;
+        version: number | null;
+        customerCount: number;
+    }>;
+    assignmentIssues: ExactDeliveryTermsDryRunIssue[];
+    resources: ExactTermsDryRunResource[];
+}
+/**
+ * One customer's Exact payment terms as the engine answers them. `status` and `classification`
+ * are the engine's own spelling (lowercase: `assigned`, `single_due_date`, …), not the
+ * uppercase enums of the provider-neutral `customers.credit.paymentTerms`.
+ */
+export interface ExactCustomerPaymentTerms {
+    customerId: string;
+    /** `exact-online`. */
+    source: string;
+    /** Exact governs the customer's terms; false while the mirror is only staged. */
+    managedExternally: boolean;
+    /** The customer is linked to an Exact Account. */
+    linkedExternally: boolean;
+    status: string;
+    stale: boolean;
+    exactAccountId: string | null;
+    exactAccountCode: string | null;
+    conditionCode: string | null;
+    conditionDescription: string | null;
+    /** The terms in a sentence. */
+    summary: string;
+    classification: string;
+    paymentDays: number | null;
+    paymentEndOfMonths: number | null;
+    paymentMethod: string | null;
+    percentage: number | null;
+    discountPaymentDays: number | null;
+    discountPercentage: number | null;
+    paymentDiscountType: string | null;
+    /** When Exact last changed the Account's condition. */
+    syncedAt: string | null;
+    /**
+     * When a sync last confirmed these terms against Exact. `syncedAt` only moves when the Account
+     * changes there, so it ages on a healthy customer.
+     */
+    lastCheckedAt: string | null;
+    error: string | null;
+}
+/**
+ * One customer's Exact delivery assignment as the engine answers it, staged ones included. The
+ * statuses and `deliveryAdvice` are the engine's own spelling (lowercase: `assigned`,
+ * `partial_allowed`, …).
+ */
+export interface ExactCustomerDeliveryTerms {
+    customerId: string;
+    source: string;
+    managedExternally: boolean;
+    linkedExternally: boolean;
+    status: string;
+    shippingMethodStatus: string;
+    policyStatus: string;
+    summary: string;
+    exactAccountId: string | null;
+    exactAccountCode: string | null;
+    preferredShippingMethodId: string | null;
+    preferredShippingMethodCode: string | null;
+    preferredShippingMethodName: string | null;
+    preferredShippingMethodAvailable: boolean;
+    eligibleShippingMethodIds: string[];
+    incotermStatus: string;
+    incotermCode: string | null;
+    incotermVersion: number | null;
+    incotermAddress: string | null;
+    incotermDescription: string | null;
+    shippingLeadDays: number | null;
+    deliveryAdvice: string;
+    stale: boolean;
+    syncedAt: string | null;
+    /** As {@link ExactCustomerPaymentTerms.lastCheckedAt}. */
+    lastCheckedAt: string | null;
+    error: string | null;
+}
+/**
+ * Where one customer stands in the Exact → platform price-list reconcile:
+ * - `assigned`: in the Exact price-list group, and that group has a price list;
+ * - `pending`: Exact says the Account has a price list, not reconciled yet;
+ * - `none`: linked to Exact, and the Account has no price list;
+ * - `unlinked`: the customer has no Exact Account link.
+ */
+export type ExactCustomerPriceListStatus = 'assigned' | 'pending' | 'none' | 'unlinked';
+/** One customer's Exact price-list link: what Exact says against what the store has. */
+export interface ExactCustomerPriceList {
+    customerId: string;
+    exactAccountId: string | null;
+    exactAccountCode: string | null;
+    exactPriceListId: string | null;
+    /** The customer group mirroring the Exact price list, once reconciled. */
+    groupId: string | null;
+    groupName: string | null;
+    /** The price list attached to that group, once reconciled. */
+    priceListId: string | null;
+    priceListName: string | null;
+    status: ExactCustomerPriceListStatus;
+    /** The newest price-list reconcile of the store, whatever it touched. */
+    lastReconciledAt: string | null;
+    /** That run's error; null when it succeeded or none ran. */
+    lastError: string | null;
+}
+/** An order's place in Exact, and what blocks a push. */
+export interface ExactOrderState {
+    /** Pushed from this store into the connected division. */
+    pushed: boolean;
+    /** `pushed` (sent from here), `imported` (came from Exact), or null (not in Exact). */
+    origin: 'pushed' | 'imported' | null;
+    salesOrderId: string | null;
+    salesOrderNumber: string | null;
+    pushedAt: string | null;
+    /** False for a guest order, which cannot be pushed. */
+    hasCustomer: boolean;
+    /** The customer is linked to an Exact Account of the connected division. */
+    customerLinked: boolean;
+    /** Lines whose variant is not linked to an Exact item; a push refuses them. */
+    unmappedSkus: string[];
+    /** How Exact's sales order differs from this order, in plain words; empty when it matches. */
+    warnings: string[];
+}
+/** An imported order's inbound (Exact → platform) sync state. */
+export interface ExactOrderSyncState {
+    exactSalesOrderId: string;
+    exactOrderNumber: string | null;
+    /** How many times the import wrote the order. */
+    revision: number;
+    lastSyncedAt: string | null;
+    /** Exact's order changed in a way the import could not apply. */
+    driftDetected: boolean;
+    /** When Exact deleted the sales order; null while it exists. */
+    exactDeletedAt: string | null;
+    unmappedSkus: string[];
+}
+/** What a push answered. A refusal is `success: false` with the reason, not a throw. */
+export interface ExactOrderPushResult {
+    success: boolean;
+    /** The order was already in Exact: nothing was written. */
+    alreadyPushed: boolean;
+    salesOrderId: string | null;
+    salesOrderNumber: string | null;
+    error: string | null;
+    errorCode: string | null;
+    /** How the sales order the push created differs from the order; null or empty when it matches. */
+    warnings: string[] | null;
+}
+/** What repricing one imported order answered. A refusal is `success: false`, not a throw. */
+export interface ExactOrderRepriceResult {
+    success: boolean;
+    /** Any line's tax split changed. */
+    changed: boolean;
+    linesRepriced: number;
+    error: string | null;
+}
+/** What repricing every imported order of the store answered. */
+export interface ExactOrderRepriceAllResult {
+    /** The imported orders of the connected division. */
+    total: number;
+    repriced: number;
+    /** Already right, or no longer linked to an order. */
+    skipped: number;
+    failed: number;
+}
+/** A product's Exact ownership (what the product editor's "Managed by Exact" banner reads). */
+export interface ExactProductStatus {
+    /** Exact owns the product's catalogue data; null on a product the sync never touched. */
+    exactManaged: boolean | null;
+    exactItemId: string | null;
+    exactItemGroupId: string | null;
+    /**
+     * The catalogue sync's signature on a disable: set, the sync switched the product off and
+     * owns switching it back on; null, a human did (or it is enabled). Never write it back.
+     */
+    exactDisabledReason: string | null;
+}