@sixtyninecommerce/admin 0.11.0 → 0.13.0

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

@@ -421,3 +421,545 @@ export interface ExactSyncEstimate {
     /** 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;
+}