@endora-commerce/contracts 0.100.0

package/dist/orders.d.ts

@@ -0,0 +1,1175 @@
+import { z } from 'zod';
+/**
+ * Orders module contracts — Source of truth per Principle V.
+ * See specs/001-b2b-platform-foundation/contracts/orders.contract.md.
+ */
+/**
+ * Configurable order status code (feature 038). Was a fixed enum
+ * (`orderStatusSchema`); with the data-driven lifecycle the authoritative
+ * status is a code validated in-service against the configured `order_statuses`
+ * set.
+ */
+export declare const orderStatusCodeSchema: z.ZodString;
+export declare const orderItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodString;
+    productSnapshot: z.ZodObject<{
+        sku: z.ZodString;
+        name: z.ZodString;
+        primaryAssetUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    variantId: z.ZodNullable<z.ZodString>;
+    variantSnapshot: z.ZodNullable<z.ZodObject<{
+        sku: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    quantity: z.ZodNumber;
+    unitPrice: z.ZodNumber;
+    taxRate: z.ZodNumber;
+    lineTotal: z.ZodNumber;
+}, z.core.$strip>;
+export type OrderItem = z.infer<typeof orderItemSchema>;
+export declare const nextActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"redirect_to_gateway">;
+    url: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"awaiting_transfer">;
+    accountDetails: z.ZodObject<{
+        accountNumber: z.ZodString;
+        accountHolder: z.ZodString;
+        bankName: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        reference: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"none">;
+}, z.core.$strip>], "kind">;
+export type NextAction = z.infer<typeof nextActionSchema>;
+export declare const orderSchema: z.ZodObject<{
+    id: z.ZodString;
+    businessId: z.ZodString;
+    organizationId: z.ZodString;
+    placedByCustomerAccountId: z.ZodString;
+    placedOnBehalfByAdminUserId: z.ZodNullable<z.ZodString>;
+    salesChannelId: z.ZodString;
+    status: z.ZodString;
+    statusName: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    statusDefaultName: z.ZodOptional<z.ZodString>;
+    paymentStatus: z.ZodEnum<{
+        paid: "paid";
+        awaiting_payment: "awaiting_payment";
+        failed: "failed";
+        deferred: "deferred";
+        refunded: "refunded";
+    }>;
+    deliveryAddress: z.ZodObject<{
+        recipientName: z.ZodString;
+        street: z.ZodString;
+        city: z.ZodString;
+        postalCode: z.ZodString;
+        country: z.ZodString;
+        phone: z.ZodOptional<z.ZodString>;
+        companyName: z.ZodOptional<z.ZodString>;
+        taxId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    billingAddress: z.ZodObject<{
+        recipientName: z.ZodString;
+        street: z.ZodString;
+        city: z.ZodString;
+        postalCode: z.ZodString;
+        country: z.ZodString;
+        phone: z.ZodOptional<z.ZodString>;
+        companyName: z.ZodOptional<z.ZodString>;
+        taxId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    deliveryPoint: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        pointId: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    deliveryMethod: z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        name: z.ZodString;
+        cost: z.ZodNumber;
+    }, z.core.$strip>;
+    paymentMethod: z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            bank_transfer: "bank_transfer";
+            pickup: "pickup";
+            credit_limit: "credit_limit";
+            gateway: "gateway";
+        }>;
+    }, z.core.$strip>;
+    sourceQuoteRequestId: z.ZodNullable<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        productId: z.ZodString;
+        productSnapshot: z.ZodObject<{
+            sku: z.ZodString;
+            name: z.ZodString;
+            primaryAssetUrl: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        variantId: z.ZodNullable<z.ZodString>;
+        variantSnapshot: z.ZodNullable<z.ZodObject<{
+            sku: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>;
+        quantity: z.ZodNumber;
+        unitPrice: z.ZodNumber;
+        taxRate: z.ZodNumber;
+        lineTotal: z.ZodNumber;
+    }, z.core.$strip>>;
+    subtotal: z.ZodNumber;
+    taxTotal: z.ZodNumber;
+    discountTotal: z.ZodNumber;
+    appliedPromotions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        promotionId: z.ZodString;
+        couponId: z.ZodNullable<z.ZodString>;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>>>;
+    deliveryTotal: z.ZodNumber;
+    total: z.ZodNumber;
+    currency: z.ZodString;
+    placedAt: z.ZodString;
+    customerNote: z.ZodNullable<z.ZodString>;
+    nextAction: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"redirect_to_gateway">;
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"awaiting_transfer">;
+        accountDetails: z.ZodObject<{
+            accountNumber: z.ZodString;
+            accountHolder: z.ZodString;
+            bankName: z.ZodString;
+            amount: z.ZodNumber;
+            currency: z.ZodString;
+            reference: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"none">;
+    }, z.core.$strip>], "kind">>;
+    customerCancellable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type Order = z.infer<typeof orderSchema>;
+export declare const placeOrderRequestSchema: z.ZodObject<{
+    deliveryAddressId: z.ZodString;
+    billingAddressId: z.ZodString;
+    deliveryMethodId: z.ZodString;
+    paymentMethodId: z.ZodString;
+    salesChannelId: z.ZodOptional<z.ZodString>;
+    promotionCode: z.ZodOptional<z.ZodString>;
+    customerNote: z.ZodOptional<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    billingCompanyName: z.ZodOptional<z.ZodString>;
+    billingTaxId: z.ZodOptional<z.ZodString>;
+    deliveryPoint: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        pointId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    shippingAdapterData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type PlaceOrderRequest = z.infer<typeof placeOrderRequestSchema>;
+/**
+ * Read-only order-total preview for the active cart with a chosen delivery +
+ * payment method (feature 049). Computes the exact total server-side — including
+ * per-product VAT, delivery cost, payment surcharge, and promotion discount —
+ * so the storefront never re-derives pricing on the client. `billingAddressId`
+ * refines the tax country to match placement; omit ⇒ the organization's country.
+ */
+export declare const orderPreviewTotalRequestSchema: z.ZodObject<{
+    deliveryMethodId: z.ZodString;
+    paymentMethodId: z.ZodString;
+    billingAddressId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type OrderPreviewTotalRequest = z.infer<typeof orderPreviewTotalRequestSchema>;
+export declare const orderPreviewTotalResponseSchema: z.ZodObject<{
+    subtotal: z.ZodNumber;
+    taxTotal: z.ZodNumber;
+    deliveryTotal: z.ZodNumber;
+    paymentSurcharge: z.ZodNumber;
+    discountTotal: z.ZodNumber;
+    total: z.ZodNumber;
+    currency: z.ZodString;
+}, z.core.$strip>;
+export type OrderPreviewTotalResponse = z.infer<typeof orderPreviewTotalResponseSchema>;
+export declare const adminOrderStatusTransitionSchema: z.ZodObject<{
+    to: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const adminOrderPaymentStatusTransitionSchema: z.ZodObject<{
+    to: z.ZodEnum<{
+        paid: "paid";
+        refunded: "refunded";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    invoiceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const adminOrderRefundRequestSchema: z.ZodObject<{
+    amount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const adminOrderShippedRequestSchema: z.ZodObject<{
+    trackingNumber: z.ZodString;
+    carrierCode: z.ZodString;
+    shippedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Status badge colour — an arbitrary `#rrggbb` hex value. The admin colour
+ * picker offers a curated preset palette plus a free custom colour. The default
+ * is a neutral slate, matching the legacy uncoloured look.
+ */
+export declare const ORDER_STATUS_DEFAULT_COLOR = "#64748b";
+/** Curated preset palette surfaced by the admin colour picker. */
+export declare const ORDER_STATUS_COLOR_PRESETS: readonly ["#64748b", "#3b82f6", "#10b981", "#f59e0b", "#ef4444", "#8b5cf6"];
+export declare const orderStatusColorSchema: z.ZodString;
+export type OrderStatusColor = z.infer<typeof orderStatusColorSchema>;
+export declare const orderStatusDefSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    defaultName: z.ZodString;
+    isInitial: z.ZodBoolean;
+    isTerminal: z.ZodBoolean;
+    isSystem: z.ZodBoolean;
+    weight: z.ZodNumber;
+    color: z.ZodString;
+    inUseCount: z.ZodNumber;
+}, z.core.$strip>;
+export type OrderStatusDefDto = z.infer<typeof orderStatusDefSchema>;
+export declare const orderStatusTransitionDtoSchema: z.ZodObject<{
+    fromStatusCode: z.ZodString;
+    toStatusCode: z.ZodString;
+    isSystem: z.ZodBoolean;
+}, z.core.$strip>;
+export type OrderStatusTransitionDto = z.infer<typeof orderStatusTransitionDtoSchema>;
+export declare const orderStatusGraphResponseSchema: z.ZodObject<{
+    statuses: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        name: z.ZodRecord<z.ZodString, z.ZodString>;
+        defaultName: z.ZodString;
+        isInitial: z.ZodBoolean;
+        isTerminal: z.ZodBoolean;
+        isSystem: z.ZodBoolean;
+        weight: z.ZodNumber;
+        color: z.ZodString;
+        inUseCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    transitions: z.ZodArray<z.ZodObject<{
+        fromStatusCode: z.ZodString;
+        toStatusCode: z.ZodString;
+        isSystem: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OrderStatusGraphResponse = z.infer<typeof orderStatusGraphResponseSchema>;
+export declare const createOrderStatusRequestSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    defaultName: z.ZodString;
+    isTerminal: z.ZodOptional<z.ZodBoolean>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateOrderStatusRequest = z.infer<typeof createOrderStatusRequestSchema>;
+export declare const updateOrderStatusRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    defaultName: z.ZodOptional<z.ZodString>;
+    isTerminal: z.ZodOptional<z.ZodBoolean>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UpdateOrderStatusRequest = z.infer<typeof updateOrderStatusRequestSchema>;
+export declare const setOrderTransitionsRequestSchema: z.ZodObject<{
+    add: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fromStatusCode: z.ZodString;
+        toStatusCode: z.ZodString;
+    }, z.core.$strip>>>;
+    remove: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fromStatusCode: z.ZodString;
+        toStatusCode: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SetOrderTransitionsRequest = z.infer<typeof setOrderTransitionsRequestSchema>;
+export declare const adminOrdersListQuerySchema: z.ZodObject<{
+    status: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
+    paymentStatus: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        paid: "paid";
+        awaiting_payment: "awaiting_payment";
+        failed: "failed";
+        deferred: "deferred";
+        refunded: "refunded";
+    }>, z.ZodArray<z.ZodEnum<{
+        paid: "paid";
+        awaiting_payment: "awaiting_payment";
+        failed: "failed";
+        deferred: "deferred";
+        refunded: "refunded";
+    }>>]>>, z.ZodTransform<("paid" | "awaiting_payment" | "failed" | "deferred" | "refunded")[] | undefined, "paid" | "awaiting_payment" | "failed" | "deferred" | "refunded" | ("paid" | "awaiting_payment" | "failed" | "deferred" | "refunded")[] | undefined>>;
+    salesChannelId: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
+    paymentMethodId: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
+    deliveryMethodId: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    orgName: z.ZodOptional<z.ZodString>;
+    customerName: z.ZodOptional<z.ZodString>;
+    placedFrom: z.ZodOptional<z.ZodString>;
+    placedTo: z.ZodOptional<z.ZodString>;
+    totalMin: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    totalMax: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    sort: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    pageSize: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type AdminOrdersListQuery = z.infer<typeof adminOrdersListQuerySchema>;
+export declare const adminOrderRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    businessId: z.ZodString;
+    customerName: z.ZodNullable<z.ZodString>;
+    organizationId: z.ZodString;
+    organizationName: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    statusName: z.ZodRecord<z.ZodString, z.ZodString>;
+    paymentStatus: z.ZodEnum<{
+        paid: "paid";
+        awaiting_payment: "awaiting_payment";
+        failed: "failed";
+        deferred: "deferred";
+        refunded: "refunded";
+    }>;
+    total: z.ZodNumber;
+    currency: z.ZodString;
+    placedAt: z.ZodString;
+    createdAt: z.ZodString;
+    salesChannelId: z.ZodString;
+    salesChannelName: z.ZodNullable<z.ZodString>;
+    deliveryMethodName: z.ZodNullable<z.ZodString>;
+    paymentMethodName: z.ZodNullable<z.ZodString>;
+    shipToName: z.ZodNullable<z.ZodString>;
+    billToName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AdminOrderRow = z.infer<typeof adminOrderRowSchema>;
+export declare const adminOrdersListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        businessId: z.ZodString;
+        customerName: z.ZodNullable<z.ZodString>;
+        organizationId: z.ZodString;
+        organizationName: z.ZodNullable<z.ZodString>;
+        status: z.ZodString;
+        statusName: z.ZodRecord<z.ZodString, z.ZodString>;
+        paymentStatus: z.ZodEnum<{
+            paid: "paid";
+            awaiting_payment: "awaiting_payment";
+            failed: "failed";
+            deferred: "deferred";
+            refunded: "refunded";
+        }>;
+        total: z.ZodNumber;
+        currency: z.ZodString;
+        placedAt: z.ZodString;
+        createdAt: z.ZodString;
+        salesChannelId: z.ZodString;
+        salesChannelName: z.ZodNullable<z.ZodString>;
+        deliveryMethodName: z.ZodNullable<z.ZodString>;
+        paymentMethodName: z.ZodNullable<z.ZodString>;
+        shipToName: z.ZodNullable<z.ZodString>;
+        billToName: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+    counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    paymentStatusCounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export type AdminOrdersListResponse = z.infer<typeof adminOrdersListResponseSchema>;
+export declare const bulkOrderStatusRequestSchema: z.ZodObject<{
+    orderIds: z.ZodArray<z.ZodString>;
+    toStatusCode: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BulkOrderStatusRequest = z.infer<typeof bulkOrderStatusRequestSchema>;
+export declare const bulkOrderStatusResponseSchema: z.ZodObject<{
+    changed: z.ZodArray<z.ZodString>;
+    skipped: z.ZodArray<z.ZodObject<{
+        orderId: z.ZodString;
+        reason: z.ZodEnum<{
+            not_found: "not_found";
+            invalid_transition: "invalid_transition";
+            terminal: "terminal";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BulkOrderStatusResponse = z.infer<typeof bulkOrderStatusResponseSchema>;
+export declare const bulkPrintInvoicesRequestSchema: z.ZodObject<{
+    orderIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type BulkPrintInvoicesRequest = z.infer<typeof bulkPrintInvoicesRequestSchema>;
+export declare const orderSavedViewSortSchema: z.ZodObject<{
+    field: z.ZodString;
+    dir: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>;
+export declare const orderSavedViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    shared: z.ZodBoolean;
+    ownerAdminUserId: z.ZodString;
+    filters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    sort: z.ZodObject<{
+        field: z.ZodString;
+        dir: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>;
+    visibleColumns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type OrderSavedView = z.infer<typeof orderSavedViewSchema>;
+export declare const createOrderSavedViewRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    shared: z.ZodBoolean;
+    filters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    sort: z.ZodObject<{
+        field: z.ZodString;
+        dir: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>;
+    visibleColumns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type CreateOrderSavedViewRequest = z.infer<typeof createOrderSavedViewRequestSchema>;
+export declare const updateOrderSavedViewRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    shared: z.ZodOptional<z.ZodBoolean>;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        dir: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
+    visibleColumns: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>>;
+}, z.core.$strip>;
+export type UpdateOrderSavedViewRequest = z.infer<typeof updateOrderSavedViewRequestSchema>;
+export declare const adminCreateOrderItemSchema: z.ZodObject<{
+    productId: z.ZodString;
+    variantId: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * A brand-new address typed inline on the admin create-order form, instead of
+ * picking an existing one from the customer's organization address book. The
+ * address is always snapshotted onto the order; `saveToAddressBook` controls
+ * whether it is also persisted to the org book for reuse (false = one-time).
+ */
+export declare const adminCreateOrderInlineAddressSchema: z.ZodObject<{
+    recipientName: z.ZodString;
+    street: z.ZodString;
+    city: z.ZodString;
+    postalCode: z.ZodString;
+    country: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    saveToAddressBook: z.ZodBoolean;
+}, z.core.$strip>;
+export type AdminCreateOrderInlineAddress = z.infer<typeof adminCreateOrderInlineAddressSchema>;
+export declare const adminCreateOrderRequestSchema: z.ZodObject<{
+    customerAccountId: z.ZodString;
+    salesChannelId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        variantId: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+    deliveryMethodId: z.ZodString;
+    paymentMethodId: z.ZodString;
+    deliveryAddressId: z.ZodOptional<z.ZodString>;
+    billingAddressId: z.ZodOptional<z.ZodString>;
+    deliveryAddress: z.ZodOptional<z.ZodObject<{
+        recipientName: z.ZodString;
+        street: z.ZodString;
+        city: z.ZodString;
+        postalCode: z.ZodString;
+        country: z.ZodString;
+        phone: z.ZodOptional<z.ZodString>;
+        saveToAddressBook: z.ZodBoolean;
+    }, z.core.$strip>>;
+    billingAddress: z.ZodOptional<z.ZodObject<{
+        recipientName: z.ZodString;
+        street: z.ZodString;
+        city: z.ZodString;
+        postalCode: z.ZodString;
+        country: z.ZodString;
+        phone: z.ZodOptional<z.ZodString>;
+        saveToAddressBook: z.ZodBoolean;
+    }, z.core.$strip>>;
+    customerNote: z.ZodOptional<z.ZodString>;
+    comment: z.ZodOptional<z.ZodObject<{
+        body: z.ZodString;
+        isCustomerVisible: z.ZodBoolean;
+        notifyCustomer: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AdminCreateOrderRequest = z.infer<typeof adminCreateOrderRequestSchema>;
+/**
+ * Inline address for the external order-intake body — the admin-create
+ * pattern: per side, the caller supplies EITHER an existing org address id OR
+ * an inline address. `saveToAddressBook` defaults to a one-time address (the
+ * org book stays clean; the order keeps its own snapshot).
+ */
+export declare const apiInlineAddressSchema: z.ZodObject<{
+    recipientName: z.ZodString;
+    street: z.ZodString;
+    city: z.ZodString;
+    postalCode: z.ZodString;
+    country: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    saveToAddressBook: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ApiInlineAddress = z.infer<typeof apiInlineAddressSchema>;
+/**
+ * `POST /api/v1/external/orders` body (bound API keys only). Line items are
+ * addressed by SKU + quantity; the response reuses the existing serialized
+ * order envelope — no bespoke partner DTO.
+ */
+export declare const apiPlaceOrderRequestSchema: z.ZodObject<{
+    lines: z.ZodArray<z.ZodObject<{
+        sku: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+    deliveryMethodId: z.ZodString;
+    paymentMethodId: z.ZodString;
+    deliveryAddressId: z.ZodOptional<z.ZodString>;
+    billingAddressId: z.ZodOptional<z.ZodString>;
+    deliveryAddress: z.ZodOptional<z.ZodObject<{
+        recipientName: z.ZodString;
+        street: z.ZodString;
+        city: z.ZodString;
+        postalCode: z.ZodString;
+        country: z.ZodString;
+        phone: z.ZodOptional<z.ZodString>;
+        saveToAddressBook: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    billingAddress: z.ZodOptional<z.ZodObject<{
+        recipientName: z.ZodString;
+        street: z.ZodString;
+        city: z.ZodString;
+        postalCode: z.ZodString;
+        country: z.ZodString;
+        phone: z.ZodOptional<z.ZodString>;
+        saveToAddressBook: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    customerReference: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ApiPlaceOrderRequest = z.infer<typeof apiPlaceOrderRequestSchema>;
+export declare const adminOrderPreviewRequestSchema: z.ZodObject<{
+    customerAccountId: z.ZodString;
+    salesChannelId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        variantId: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+    deliveryMethodId: z.ZodOptional<z.ZodString>;
+    paymentMethodId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AdminOrderPreviewRequest = z.infer<typeof adminOrderPreviewRequestSchema>;
+export declare const adminOrderPreviewLineSchema: z.ZodObject<{
+    productId: z.ZodString;
+    variantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    quantity: z.ZodNumber;
+    unitPrice: z.ZodString;
+    currency: z.ZodString;
+    lineTotal: z.ZodNumber;
+    unavailable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const adminOrderPreviewResponseSchema: z.ZodObject<{
+    lines: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        variantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        quantity: z.ZodNumber;
+        unitPrice: z.ZodString;
+        currency: z.ZodString;
+        lineTotal: z.ZodNumber;
+        unavailable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        subtotal: z.ZodNumber;
+        taxTotal: z.ZodNumber;
+        deliveryTotal: z.ZodNumber;
+        paymentSurcharge: z.ZodNumber;
+        discountTotal: z.ZodNumber;
+        total: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>;
+    messages: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        code: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AdminOrderPreviewResponse = z.infer<typeof adminOrderPreviewResponseSchema>;
+export declare const orderCommentSchema: z.ZodObject<{
+    id: z.ZodString;
+    orderId: z.ZodString;
+    authorAdminUserId: z.ZodNullable<z.ZodString>;
+    authorCustomerAccountId: z.ZodNullable<z.ZodString>;
+    body: z.ZodString;
+    isCustomerVisible: z.ZodBoolean;
+    notifyCustomer: z.ZodBoolean;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type OrderComment = z.infer<typeof orderCommentSchema>;
+export declare const adminAddOrderCommentRequestSchema: z.ZodObject<{
+    body: z.ZodString;
+    isCustomerVisible: z.ZodBoolean;
+    notifyCustomer: z.ZodBoolean;
+}, z.core.$strip>;
+export type AdminAddOrderCommentRequest = z.infer<typeof adminAddOrderCommentRequestSchema>;
+export declare const customerAddOrderCommentRequestSchema: z.ZodObject<{
+    body: z.ZodString;
+}, z.core.$strip>;
+export type CustomerAddOrderCommentRequest = z.infer<typeof customerAddOrderCommentRequestSchema>;
+export declare const reorderUnavailableItemSchema: z.ZodObject<{
+    productId: z.ZodString;
+    variantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reason: z.ZodEnum<{
+        out_of_stock: "out_of_stock";
+        discontinued: "discontinued";
+        out_of_catalog_scope: "out_of_catalog_scope";
+        no_price: "no_price";
+    }>;
+}, z.core.$strip>;
+export declare const customerReorderResponseSchema: z.ZodObject<{
+    cartId: z.ZodString;
+    checkoutUrl: z.ZodString;
+    unavailableItems: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        variantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reason: z.ZodEnum<{
+            out_of_stock: "out_of_stock";
+            discontinued: "discontinued";
+            out_of_catalog_scope: "out_of_catalog_scope";
+            no_price: "no_price";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CustomerReorderResponse = z.infer<typeof customerReorderResponseSchema>;
+export declare const adminReorderResponseSchema: z.ZodObject<{
+    newOrderId: z.ZodOptional<z.ZodString>;
+    cartId: z.ZodOptional<z.ZodString>;
+    unavailableItems: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        variantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reason: z.ZodEnum<{
+            out_of_stock: "out_of_stock";
+            discontinued: "discontinued";
+            out_of_catalog_scope: "out_of_catalog_scope";
+            no_price: "no_price";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AdminReorderResponse = z.infer<typeof adminReorderResponseSchema>;
+export declare const cloneOrderToQuoteResponseSchema: z.ZodObject<{
+    quoteRequestId: z.ZodString;
+}, z.core.$strip>;
+export type CloneOrderToQuoteResponse = z.infer<typeof cloneOrderToQuoteResponseSchema>;
+/**
+ * The two lifecycle statuses that are **not** admin-configurable, materialised
+ * with universal edges at seed time (feature 038, data-model.md §2), plus the
+ * initial one.
+ *
+ * Published as **constants, not a port** (FR-013): switching `orders` off does
+ * not change the spelling of `'on_hold'`, and a gated port answering 503 to
+ * "what is the on-hold status code" would be a bug. `payments` compares against
+ * the first of them when a gateway reports a partial capture.
+ */
+export declare const ORDER_STATUS_ON_HOLD = "on_hold";
+export declare const ORDER_STATUS_CANCELLED = "cancelled";
+export declare const ORDER_STATUS_INITIAL = "new";
+/**
+ * The money axis of an order.
+ *
+ * `failed` is set by the settlement ingress when a gateway declines a payment
+ * (feature 085, FR-001). The wire vocabulary — `paymentStatusSchema` in
+ * `common.ts` — has carried the value since feature 034, so nothing on the wire
+ * changes here; what changed is that the platform can now produce it. It is
+ * **system-written only**: `adminOrderPaymentStatusTransitionSchema` accepts
+ * `paid` and `refunded` and nothing else, so an operator can see a failed
+ * payment but never set one.
+ */
+export type OrderPaymentStatus = 'awaiting_payment' | 'paid' | 'failed' | 'deferred' | 'refunded';
+export interface OrderAddressSnapshot {
+    recipientName: string;
+    street: string;
+    city: string;
+    postalCode: string;
+    country: string;
+    phone?: string | null;
+    /** Billing only — company name and tax id captured at placement. */
+    companyName?: string | null;
+    taxId?: string | null;
+}
+export interface OrderDeliveryMethodSnapshot {
+    code: string;
+    name: string;
+    cost: number;
+}
+export interface OrderDeliveryPointSnapshot {
+    provider: string;
+    pointId: string;
+    label?: string | null;
+    address?: string | null;
+}
+export interface OrderPaymentMethodSnapshot {
+    code: string;
+    name: string;
+    kind: 'bank_transfer' | 'pickup' | 'credit_limit' | 'gateway';
+    /** Feature 034 — adapter registry key the order was placed with. */
+    adapter?: string;
+    /** Feature 034 — flat payment surcharge captured at placement. */
+    additionalPrice?: number;
+}
+/**
+ * An order as it crosses a module boundary — a plain shape, never the ORM
+ * entity (FR-011).
+ *
+ * The money columns keep their `string` form. They are `decimal(14,2)` and the
+ * entity carries them as strings for exactly one reason: a `number` cannot
+ * round-trip a monetary value, and the four payment gateways that read this
+ * record all forward the figure to a provider.
+ *
+ * `status` is a `string` rather than a union because the lifecycle is
+ * admin-configurable (feature 038 FR-001/FR-006) — the set of statuses is a
+ * table, not an enum, and a consumer that narrowed it would break the first
+ * time an operator added one.
+ */
+export interface OrderRecord {
+    id: string;
+    businessId: string;
+    organizationId: string;
+    placedByCustomerAccountId: string;
+    placedOnBehalfByAdminUserId: string | null;
+    salesChannelId: string;
+    status: string;
+    paymentStatus: OrderPaymentStatus;
+    deliveryAddress: OrderAddressSnapshot;
+    billingAddress: OrderAddressSnapshot;
+    deliveryPointSnapshot?: OrderDeliveryPointSnapshot | null;
+    /**
+     * The adapter-specific shipping envelope captured at placement (feature 068).
+     * Opaque here on purpose: only the delivery method's own `ShippingAdapter`
+     * knows its shape, and it is published on the record so a carrier module can
+     * read the order it is shipping over `OrderReadPort` rather than reaching for
+     * this module's entity.
+     */
+    shippingAdapterData?: Record<string, unknown> | null;
+    deliveryMethodId: string;
+    deliveryMethodSnapshot: OrderDeliveryMethodSnapshot;
+    paymentMethodId: string;
+    paymentMethodSnapshot: OrderPaymentMethodSnapshot;
+    sourceQuoteRequestId: string | null;
+    subtotal: string;
+    taxTotal: string;
+    discountTotal: string;
+    deliveryTotal: string;
+    total: string;
+    currency: string;
+    promotionCode: string | null;
+    customerNote: string | null;
+    placedAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    customFieldValues: Record<string, unknown>;
+}
+/** One line of an order, as `invoices` reads it. */
+export interface OrderItemRecord {
+    id: string;
+    orderId: string;
+    productId: string;
+    productSnapshot: {
+        sku: string;
+        name: string;
+        slug?: string | null;
+    };
+    variantId: string | null;
+    variantSnapshot: {
+        sku: string;
+        label: string;
+    } | null;
+    packagingUnitSnapshot: {
+        name: string;
+        baseQuantity: number;
+    } | null;
+    quantity: number;
+    unitPrice: string;
+    taxRate: string;
+    lineTotal: string;
+    createdAt: Date;
+}
+/**
+ * Container name: `orderReadPort`. Owner: `orders`.
+ *
+ * Thirty-three of the 42 inbound sites are `em.findOne(Order, { id })` — four
+ * payment gateways, `invoices`, `shipments`, `quote_requests` and the export
+ * adapter each spelling the same lookup. That is what this port is.
+ *
+ * When `orders` is off every method fails closed, and that is the answer a
+ * gateway callback should get: acknowledging a payment against an order the
+ * platform will not read is worse than making the provider retry.
+ *
+ * Whether `orders` has an off state at all is its manifest's `activation` to
+ * say, not this line's: a module declaring `nonDeactivatable` never enters one.
+ */
+export interface OrderReadPort {
+    findById(id: string): Promise<OrderRecord | null>;
+    findByIds(ids: readonly string[]): Promise<OrderRecord[]>;
+    /** Every order, newest first — for the bulk export adapter. */
+    listAll(): Promise<OrderRecord[]>;
+    /** The order's lines, in insertion order. */
+    listItems(orderId: string): Promise<OrderItemRecord[]>;
+    /**
+     * Ids of orders whose business id contains `fragment`, case-insensitively,
+     * capped at `limit`. An empty `fragment` returns no ids.
+     *
+     * Published after Phase P, for `invoices`' `filter[orderNumber]`. It is not
+     * {@link OrderListPort.list}'s `q`, which also matches the buying
+     * organisation and the placing customer — an invoice list filtered by "order
+     * number" that quietly matched a company name would be a different filter
+     * wearing the same label. It is not `findByIds` either: the caller has a
+     * fragment, not ids.
+     *
+     * `limit` is the caller's, applied by the owner, so the narrowing happens
+     * once. `invoices` used to `em.find(Order, { businessId: { $ilike } }, {
+     * limit: 500 })` and then narrow again against its own page size, which
+     * silently dropped matches beyond the 500th.
+     */
+    findIdsByBusinessIdLike(fragment: string, limit: number): Promise<string[]>;
+    /**
+     * The distinct sales channels one customer has ordered on, most recently
+     * ordered-on first. A customer with no orders answers `[]`.
+     *
+     * Published for feature 080's T048 (D-169), for the `customers` detail
+     * header. It is a **read**, so it is a method here and not an
+     * `EntityManager`-taking apply port: handing a read a transaction handle
+     * re-opens a write seam to serve it.
+     *
+     * It is deliberately not {@link OrderListPort.list} with a
+     * `placedByCustomerAccountId`. That read is paginated, so the channels it
+     * yields are the channels on one page, and a detail header that silently
+     * narrowed with the page size would be a different fact under the same
+     * label. `customers` used to answer it with `em.find(Order, {
+     * placedByCustomerAccountId }, { fields: ['salesChannelId'] })` inside its
+     * own module, which was unpaginated and correct and read this module's table
+     * whether this module was there or not.
+     *
+     * The ids come back **already distinct**: the deduplication is the owner's,
+     * because it is what makes the ordering meaningful — the answer is one entry
+     * per channel keyed on that customer's latest order there.
+     */
+    salesChannelIdsForCustomer(customerAccountId: string): Promise<string[]>;
+}
+/** The admin order list's filter set. Page and page size are required. */
+export interface OrderListQuery {
+    status?: string[] | undefined;
+    /** The money axis (feature 085, FR-021). */
+    paymentStatus?: string[] | undefined;
+    salesChannelId?: string[] | undefined;
+    paymentMethodId?: string[] | undefined;
+    deliveryMethodId?: string[] | undefined;
+    organizationId?: string | undefined;
+    /**
+     * Feature 040 — restrict to a single customer's own orders. Used by the
+     * customer self-service history and the admin customer-detail orders panel.
+     * Aggregates across sales channels when `salesChannelId` is omitted.
+     */
+    placedByCustomerAccountId?: string | undefined;
+    q?: string | undefined;
+    /** Dedicated org / customer name filters, AND-combined with the global `q`. */
+    orgName?: string | undefined;
+    customerName?: string | undefined;
+    placedFrom?: string | undefined;
+    placedTo?: string | undefined;
+    totalMin?: number | undefined;
+    totalMax?: number | undefined;
+    sort?: string | undefined;
+    page: number;
+    pageSize: number;
+}
+/** Restricts a list to the organisations the caller may see. */
+export interface OrderListScope {
+    allowedOrganizationIds: string[];
+}
+/**
+ * One row of the admin order list.
+ *
+ * Deliberately **not** `AdminOrderRow` from this file's HTTP section, though
+ * the fields line up: that shape narrows `paymentStatus` and `status` to the
+ * unions the API documents, and the list is served straight off a
+ * configurable-status table (feature 038 FR-001/FR-006). Reusing the narrowed
+ * type would be a lie a consumer could act on the first time an operator adds
+ * a status.
+ */
+export interface OrderListRow {
+    id: string;
+    businessId: string;
+    customerName: string | null;
+    organizationId: string;
+    organizationName: string | null;
+    status: string;
+    statusName: Record<string, string>;
+    paymentStatus: string;
+    total: number;
+    currency: string;
+    placedAt: string;
+    createdAt: string;
+    salesChannelId: string;
+    salesChannelName: string | null;
+    deliveryMethodName: string | null;
+    paymentMethodName: string | null;
+    shipToName: string | null;
+    billToName: string | null;
+}
+export interface OrderListResult {
+    rows: OrderListRow[];
+    total: number;
+    /** Per lifecycle status, over every filter except the status filter. */
+    counts: Record<string, number>;
+    /**
+     * Per payment status, over every filter except the payment-status filter
+     * (feature 085). Two maps and not one: `paid` is both a shipped order status
+     * code and a payment status, so a single map would merge two populations.
+     */
+    paymentStatusCounts: Record<string, number>;
+}
+/**
+ * Container name: `orderListPort`. Owner: `orders`.
+ *
+ * `customers` serves both the self-service order history and the admin
+ * customer-detail orders panel from this one list. It reaches it today as
+ * `Pick<OrderListService, 'list'>` — a type operator in front of a
+ * cross-module import of the class, which is the violation with punctuation on
+ * (FR-011). This is the shape that replaces it.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `orders` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface OrderListPort {
+    list(query: OrderListQuery, scope?: OrderListScope): Promise<OrderListResult>;
+}
+/** Who the buyer is, for a placement made on their behalf or by them. */
+export interface OrderCustomerContext {
+    customerAccountId: string;
+    organizationId: string;
+    /**
+     * When the request is from an admin user impersonating this customer, carry
+     * the admin's id so the order is stamped with it (FR-042 / R-12).
+     */
+    impersonatorAdminUserId?: string | null;
+}
+/**
+ * What a placement answers with: the order row **plus** the payment
+ * next-action computed during that placement.
+ *
+ * `nextAction` is not on {@link OrderRecord} and must not be: it is a virtual
+ * column (`persist: false`, `order.entity.ts`) that exists only in the reply to
+ * the call that created the order, so a *read* of an order can never carry a
+ * meaningful one. It is on this record because the one thing a caller does with
+ * a freshly placed order is route the buyer — to the gateway, to the transfer
+ * details, or to the success page.
+ *
+ * Corrected in feature 075's `quick_order` cut: the port below published
+ * `OrderRecord`, and `quick_order`'s one-click response renders `nextAction`.
+ * Cutting onto the port as published would have dropped the redirect from the
+ * one-click reply — a product change wearing a refactor, on the path
+ * MR !582 / issue #64 had just brought under test.
+ */
+export interface PlacedOrderRecord extends OrderRecord {
+    nextAction: NextAction | null;
+}
+/**
+ * Container name: `orderPlacementPort`. Owner: `orders`.
+ *
+ * `quick_order`'s one-click buy is the only consumer: it seeds the cart and
+ * then places. It already reaches the service through a lazy accessor that can
+ * answer `null`, which is how it expresses "ordering is unavailable"; the port
+ * expresses the same thing as a 503 at the seam, which is stronger — a `null`
+ * accessor is indistinguishable from a wiring mistake.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `orders` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface OrderPlacementPort {
+    placeOrder(ctx: OrderCustomerContext, req: PlaceOrderRequest): Promise<PlacedOrderRecord>;
+}
+export interface OrderStatusActor {
+    kind: 'admin' | 'customer' | 'system';
+    adminUserId?: string;
+    customerAccountId?: string;
+    source?: 'payment' | 'shipment' | 'reorder' | 'checkout';
+}
+/** What a caller announcing a committed status change has to say. */
+export interface OrderStatusChange {
+    orderId: string;
+    organizationId: string;
+    salesChannelId: string;
+    from: string;
+    to: string;
+    actor: OrderStatusActor;
+    reason?: string | null;
+    /**
+     * Feature 062 — human-readable order number for webhook receivers
+     * (contracts/order-webhooks.md §5). Optional: system-driven callers
+     * (payments, shipments) may not have it in scope.
+     */
+    businessId?: string | null;
+}
+/**
+ * Container name: `orderStatusAnnouncePort`. Owner: `orders`.
+ *
+ * `payments` and `shipments` move an order's status inside their own
+ * transaction and then have to announce it, which they do today by importing
+ * `orders`' event builder and handing it their own `EventBus`. The templated
+ * event names (`order.status.from_x_to_y.after`, `order.status.to_y.after`)
+ * are `orders`' vocabulary and must be built in one place — they are not known
+ * at compile time, because the status set is admin-configurable.
+ *
+ * A no-op when `from === to`, as the builder already is.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `orders` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface OrderStatusAnnouncePort {
+    announceStatusChanged(change: OrderStatusChange): void;
+}
+/** Why a requested transition did not happen. */
+export type OrderTransitionRefusal = 
+/** No order with that id. */
+'not_found'
+/** `to` is not a configured status code. */
+ | 'unknown_status'
+/** The configured lifecycle has no edge, or the source status is terminal. */
+ | 'not_permitted'
+/** A registered before-guard vetoed it. */
+ | 'vetoed';
+/**
+ * What became of a requested transition.
+ *
+ * `already_there` is separated from the refusals because it is not one: the
+ * order is where the caller wanted it, nothing moved, and nothing was
+ * recorded. It is the normal outcome of a second declined payment attempt on
+ * an order already held.
+ */
+export type OrderTransitionOutcome = {
+    applied: true;
+    from: string;
+    to: string;
+} | {
+    applied: false;
+    reason: 'already_there';
+    from: string;
+} | {
+    applied: false;
+    reason: OrderTransitionRefusal;
+    from: string | null;
+    detail: string;
+};
+/**
+ * Container name: `orderTransitionPort`. Owner: `orders`.
+ *
+ * The write twin of `orderStatusAnnouncePort`: that one publishes the
+ * *announcement* half of a status change, this one performs the change. Three
+ * sites in `payments` and `shipments` write `order.status` directly, and in
+ * doing so skip graph validation, the veto guards, the audit entry and the
+ * side-effects that release stock allocations and free a credit-limit
+ * reservation. This port is the seam that lets them stop (feature 085).
+ *
+ * It is not `orderTransitionServiceAccessor`, which hands out the
+ * `OrderTransitionService` class: a published port's type argument must be a
+ * contract type, and that accessor also answers `null` until the plugin body
+ * has run.
+ *
+ * **Call this after your own commit, never inside your transaction.** The
+ * implementation obtains its own EntityManager, so a caller running inside
+ * `em.transactional` would have the order written on a *different* pooled
+ * connection that commits independently — the caller's rollback cannot reach
+ * it, which is the shape `check:transaction-context` refuses (issue #200).
+ * Both settlement handlers therefore write their payment or shipment row,
+ * commit, and only then call this. The failure mode of that ordering lands on
+ * the safe side: a crash in between leaves the payment recorded and the
+ * lifecycle unmoved, which the buyer can retry, where the opposite ordering
+ * would hold an order against a payment nobody recorded.
+ *
+ * **Refusals are outcomes, not exceptions**, because both settlement callers
+ * are answering a payment service provider: a thrown refusal becomes a non-2xx
+ * callback response, which every PSP retries indefinitely. The refusal has to
+ * be visible to the caller and invisible to the provider.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. A consumer must not wrap the call in a bare `catch`, which
+ * would turn that into fail-open. Whether `orders` has an off state at all is
+ * its manifest's `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface OrderTransitionPort {
+    /**
+     * Move an order to status `to`, applying the configured lifecycle: graph
+     * validation, the before-guards, the audit entry and the status's
+     * side-effects. The caller invokes none of those and needs to know about
+     * none of them.
+     */
+    applyStatus(input: {
+        orderId: string;
+        to: string;
+        actor: OrderStatusActor;
+        reason?: string | null;
+    }): Promise<OrderTransitionOutcome>;
+    /**
+     * Whether an order's current status is terminal, per the configured graph.
+     *
+     * A caller that has to refuse acting on a finished order asks this rather
+     * than comparing against the string `'cancelled'`: the status set is
+     * operator-configurable and a deployment may add terminal statuses of its
+     * own. `null` when there is no such order, so the caller answers 404 in its
+     * own words instead of guessing.
+     */
+    isTerminal(orderId: string): Promise<boolean | null>;
+}
+/**
+ * The answer to a buyer-side claim on an order's GA4 `purchase` conversion
+ * (issue #277).
+ *
+ * `counted: true` means this caller is the one that may report the conversion;
+ * every later caller, on any device, gets `false`. The storefront asks before
+ * it fires, so the tag runs once per order and never again — which is what
+ * stops a buyer who reopens their order from being counted twice, and what
+ * lets the two surfaces that may count an order (`/checkout/success` and
+ * `/orders/:id`) share one answer instead of guessing about each other.
+ */
+export declare const purchaseConversionClaimResponseSchema: z.ZodObject<{
+    counted: z.ZodBoolean;
+}, z.core.$strip>;
+export type PurchaseConversionClaimResponse = z.infer<typeof purchaseConversionClaimResponseSchema>;
+//# sourceMappingURL=orders.d.ts.map