@endora-commerce/contracts 0.100.0

package/dist/returns.d.ts

@@ -0,0 +1,774 @@
+import { z } from 'zod';
+/**
+ * Returns & Complaints (Refunds, RMA) — feature 046.
+ *
+ * Source-of-truth Zod schemas for the returns module boundary (admin + customer
+ * APIs and the configurable workflow). Mirrors the orders module's contract
+ * organization. TS types are inferred (`z.infer`), never hand-maintained.
+ */
+/** A case is either a withdrawal-style Return or a warranty Complaint. */
+export declare const returnKindSchema: z.ZodEnum<{
+    return: "return";
+    complaint: "complaint";
+}>;
+export type ReturnKind = z.infer<typeof returnKindSchema>;
+/** Settlement resolution chosen by the admin. */
+export declare const resolutionTypeSchema: z.ZodEnum<{
+    refund: "refund";
+    credit: "credit";
+    replacement: "replacement";
+    repair: "repair";
+}>;
+export type ResolutionType = z.infer<typeof resolutionTypeSchema>;
+/** State of a recorded refund's money movement. */
+export declare const settlementStateSchema: z.ZodEnum<{
+    failed: "failed";
+    issued: "issued";
+    pending_manual: "pending_manual";
+}>;
+export type SettlementState = z.infer<typeof settlementStateSchema>;
+/** Who bears the return shipping cost. */
+export declare const returnCostBearerSchema: z.ZodEnum<{
+    customer: "customer";
+    shop: "shop";
+}>;
+export type ReturnCostBearer = z.infer<typeof returnCostBearerSchema>;
+/** Inspection outcome for a received line. */
+export declare const inspectionOutcomeSchema: z.ZodEnum<{
+    pending: "pending";
+    failed: "failed";
+    passed: "passed";
+}>;
+export type InspectionOutcome = z.infer<typeof inspectionOutcomeSchema>;
+/** Status code is a free-form machine identifier (the workflow is configurable). */
+export declare const returnStatusCodeSchema: z.ZodString;
+export declare const returnStatusSchema: 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;
+}, z.core.$strip>;
+export type ReturnStatusDto = z.infer<typeof returnStatusSchema>;
+export declare const returnTransitionSchema: z.ZodObject<{
+    fromStatusCode: z.ZodString;
+    toStatusCode: z.ZodString;
+    isSystem: z.ZodBoolean;
+}, z.core.$strip>;
+export type ReturnTransitionDto = z.infer<typeof returnTransitionSchema>;
+export declare const returnStatusGraphResponseSchema: 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 ReturnStatusGraphResponse = z.infer<typeof returnStatusGraphResponseSchema>;
+export declare const returnStatusCreateSchema: 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 declare const returnStatusUpdateSchema: 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 declare const returnTransitionsSetSchema: z.ZodObject<{
+    transitions: z.ZodArray<z.ZodObject<{
+        fromStatusCode: z.ZodString;
+        toStatusCode: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const returnCaseItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    orderItemId: z.ZodString;
+    productId: z.ZodString;
+    productName: z.ZodString;
+    quantity: z.ZodNumber;
+    reasonId: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    inspectionOutcome: z.ZodNullable<z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        passed: "passed";
+    }>>;
+    defaultRefundAmount: z.ZodNumber;
+    approvedRefundAmount: z.ZodNumber;
+}, z.core.$strip>;
+export type ReturnCaseItemDto = z.infer<typeof returnCaseItemSchema>;
+export declare const returnCaseCommentSchema: z.ZodObject<{
+    id: z.ZodString;
+    authorKind: z.ZodEnum<{
+        customer: "customer";
+        admin: "admin";
+    }>;
+    body: z.ZodString;
+    isCustomerVisible: z.ZodBoolean;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ReturnCaseCommentDto = z.infer<typeof returnCaseCommentSchema>;
+export declare const returnCaseSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    rmaNumber: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+    }>;
+    orderId: z.ZodString;
+    statusCode: z.ZodString;
+    statusLabel: z.ZodString;
+    totalRefundAmount: z.ZodNumber;
+    currency: z.ZodString;
+    submittedAt: z.ZodString;
+}, z.core.$strip>;
+export type ReturnCaseSummary = z.infer<typeof returnCaseSummarySchema>;
+/**
+ * What became of the corrective invoice for a settled case (D-92, issue #156).
+ *
+ * Three values, because `correctiveInvoiceId: null` is a two-way answer to a
+ * three-way question: it stands for "no correction was due", "none was asked
+ * for" and "one was asked for and we do not know" at once. `not_due` carries
+ * its own reason in the enum — `order_not_invoiced` is the only one there is,
+ * and a second reason becomes a fourth value rather than a free-text column.
+ *
+ * `issued` is exactly the case where the settlement holds an invoice id.
+ */
+export declare const correctiveInvoiceOutcomeSchema: z.ZodEnum<{
+    not_requested: "not_requested";
+    issued: "issued";
+    not_due: "not_due";
+}>;
+export type CorrectiveInvoiceOutcome = z.infer<typeof correctiveInvoiceOutcomeSchema>;
+/**
+ * The persisted corrective-invoice answer, as the case detail reports it.
+ *
+ * The settlement *response* (`settlementResultSchema` below) says the same
+ * thing with the document's number attached, and only at the moment of
+ * settling. This is the copy a reloaded screen reads, so it names what the
+ * `Refund` row holds and nothing else: resolving the number would mean reading
+ * `invoices` from `returns` on a screen that must keep answering while that
+ * module is off.
+ */
+export declare const returnCaseCorrectiveInvoiceSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        not_requested: "not_requested";
+        issued: "issued";
+        not_due: "not_due";
+    }>;
+    invoiceId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ReturnCaseCorrectiveInvoice = z.infer<typeof returnCaseCorrectiveInvoiceSchema>;
+export declare const returnCaseDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    rmaNumber: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+    }>;
+    orderId: z.ZodString;
+    statusCode: z.ZodString;
+    statusLabel: z.ZodString;
+    totalRefundAmount: z.ZodNumber;
+    currency: z.ZodString;
+    submittedAt: z.ZodString;
+    salesChannelId: z.ZodString;
+    customerAccountId: z.ZodString;
+    organizationId: z.ZodNullable<z.ZodString>;
+    returnDeliveryMethodId: z.ZodNullable<z.ZodString>;
+    appliedReturnCost: z.ZodNumber;
+    returnCostBearer: z.ZodEnum<{
+        customer: "customer";
+        shop: "shop";
+    }>;
+    freeReturnEligible: z.ZodBoolean;
+    resolutionType: z.ZodNullable<z.ZodEnum<{
+        refund: "refund";
+        credit: "credit";
+        replacement: "replacement";
+        repair: "repair";
+    }>>;
+    rejectionReason: z.ZodNullable<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        orderItemId: z.ZodString;
+        productId: z.ZodString;
+        productName: z.ZodString;
+        quantity: z.ZodNumber;
+        reasonId: z.ZodNullable<z.ZodString>;
+        description: z.ZodNullable<z.ZodString>;
+        inspectionOutcome: z.ZodNullable<z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            passed: "passed";
+        }>>;
+        defaultRefundAmount: z.ZodNumber;
+        approvedRefundAmount: z.ZodNumber;
+    }, z.core.$strip>>;
+    comments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        authorKind: z.ZodEnum<{
+            customer: "customer";
+            admin: "admin";
+        }>;
+        body: z.ZodString;
+        isCustomerVisible: z.ZodBoolean;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    correctiveInvoice: z.ZodNullable<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            not_requested: "not_requested";
+            issued: "issued";
+            not_due: "not_due";
+        }>;
+        invoiceId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReturnCaseDetail = z.infer<typeof returnCaseDetailSchema>;
+export declare const returnableLineSchema: z.ZodObject<{
+    orderItemId: z.ZodString;
+    productId: z.ZodString;
+    name: z.ZodString;
+    purchasedQty: z.ZodNumber;
+    remainingReturnableQty: z.ZodNumber;
+    paidUnitAmount: z.ZodNumber;
+    currency: z.ZodString;
+}, z.core.$strip>;
+export declare const returnableResponseSchema: z.ZodObject<{
+    eligible: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodEnum<{
+        order_not_completing: "order_not_completing";
+        window_passed: "window_passed";
+        fully_returned: "fully_returned";
+    }>>;
+    freeReturnEligible: z.ZodBoolean;
+    lines: z.ZodArray<z.ZodObject<{
+        orderItemId: z.ZodString;
+        productId: z.ZodString;
+        name: z.ZodString;
+        purchasedQty: z.ZodNumber;
+        remainingReturnableQty: z.ZodNumber;
+        paidUnitAmount: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReturnableResponse = z.infer<typeof returnableResponseSchema>;
+export declare const createReturnCaseRequestSchema: z.ZodObject<{
+    orderId: z.ZodString;
+    kind: z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+    }>;
+    lines: z.ZodArray<z.ZodObject<{
+        orderItemId: z.ZodString;
+        quantity: z.ZodNumber;
+        reasonId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    attachmentAssetIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    comment: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateReturnCaseRequest = z.infer<typeof createReturnCaseRequestSchema>;
+export declare const customerAddCommentRequestSchema: z.ZodObject<{
+    body: z.ZodString;
+}, z.core.$strip>;
+export declare const addReturnAttachmentRequestSchema: z.ZodObject<{
+    assetId: z.ZodString;
+    returnCaseItemId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const returnAttachmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    returnCaseId: z.ZodString;
+    returnCaseItemId: z.ZodNullable<z.ZodString>;
+    assetId: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ReturnAttachmentDto = z.infer<typeof returnAttachmentSchema>;
+export declare const adminTransitionRequestSchema: z.ZodObject<{
+    to: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const adminRejectRequestSchema: z.ZodObject<{
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const adminAddCommentRequestSchema: z.ZodObject<{
+    body: z.ZodString;
+    isCustomerVisible: z.ZodBoolean;
+    notifyCustomer: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const adminReturnRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    rmaNumber: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+    }>;
+    orderId: z.ZodString;
+    statusCode: z.ZodString;
+    statusLabel: z.ZodString;
+    totalRefundAmount: z.ZodNumber;
+    currency: z.ZodString;
+    submittedAt: z.ZodString;
+    customerName: z.ZodNullable<z.ZodString>;
+    organizationName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AdminReturnRow = z.infer<typeof adminReturnRowSchema>;
+export declare const settlementPrefillSchema: z.ZodObject<{
+    currency: z.ZodString;
+    resolutionOptions: z.ZodArray<z.ZodEnum<{
+        refund: "refund";
+        credit: "credit";
+        replacement: "replacement";
+        repair: "repair";
+    }>>;
+    items: z.ZodArray<z.ZodObject<{
+        returnCaseItemId: z.ZodString;
+        productName: z.ZodString;
+        quantity: z.ZodNumber;
+        defaultRefundAmount: z.ZodNumber;
+        approvedRefundAmount: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SettlementPrefill = z.infer<typeof settlementPrefillSchema>;
+export declare const settlementRequestSchema: z.ZodObject<{
+    resolutionType: z.ZodEnum<{
+        refund: "refund";
+        credit: "credit";
+        replacement: "replacement";
+        repair: "repair";
+    }>;
+    lines: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        returnCaseItemId: z.ZodString;
+        approvedRefundAmount: z.ZodNumber;
+    }, z.core.$strip>>>;
+    refundPaymentMethodId: z.ZodOptional<z.ZodString>;
+    createCorrectiveInvoice: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SettlementRequest = z.infer<typeof settlementRequestSchema>;
+/**
+ * What became of the corrective invoice a settlement asked for (#135).
+ *
+ * Both outcomes are stated. A settled return on an order that was never
+ * invoiced corrects no VAT document, and this says so with a reason instead of
+ * leaving the caller to read it out of a missing id — reading absence is how
+ * the never-invoiced path came to emit a document that corrected nothing.
+ */
+export declare const settlementCorrectiveInvoiceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    issued: z.ZodLiteral<true>;
+    invoiceId: z.ZodString;
+    number: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    issued: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        order_not_invoiced: "order_not_invoiced";
+    }>;
+}, z.core.$strip>], "issued">;
+export type SettlementCorrectiveInvoice = z.infer<typeof settlementCorrectiveInvoiceSchema>;
+export declare const settlementResultSchema: z.ZodObject<{
+    totalRefundAmount: z.ZodNumber;
+    refund: z.ZodOptional<z.ZodObject<{
+        settlementState: z.ZodEnum<{
+            failed: "failed";
+            issued: "issued";
+            pending_manual: "pending_manual";
+        }>;
+        externalReference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        failureReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    correctiveInvoiceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    correctiveInvoice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        issued: z.ZodLiteral<true>;
+        invoiceId: z.ZodString;
+        number: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        issued: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            order_not_invoiced: "order_not_invoiced";
+        }>;
+    }, z.core.$strip>], "issued">>;
+    creditLimitTopupApplied: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SettlementResult = z.infer<typeof settlementResultSchema>;
+export declare const returnDeliveryMethodSchema: z.ZodObject<{
+    id: z.ZodString;
+    deliveryMethodId: z.ZodString;
+    returnCost: z.ZodNumber;
+    currency: z.ZodString;
+    isActive: z.ZodBoolean;
+}, z.core.$strip>;
+export type ReturnDeliveryMethodDto = z.infer<typeof returnDeliveryMethodSchema>;
+export declare const returnDeliveryMethodCreateSchema: z.ZodObject<{
+    deliveryMethodId: z.ZodString;
+    returnCost: z.ZodNumber;
+    currency: z.ZodString;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const returnDeliveryMethodUpdateSchema: z.ZodObject<{
+    returnCost: z.ZodOptional<z.ZodNumber>;
+    currency: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const selectReturnDeliveryMethodRequestSchema: z.ZodObject<{
+    returnDeliveryMethodId: z.ZodString;
+}, z.core.$strip>;
+export declare const selectReturnDeliveryMethodResultSchema: z.ZodObject<{
+    appliedReturnCost: z.ZodNumber;
+    returnCostBearer: z.ZodEnum<{
+        customer: "customer";
+        shop: "shop";
+    }>;
+    currency: z.ZodString;
+}, z.core.$strip>;
+export declare const returnShipmentDirectionSchema: z.ZodEnum<{
+    replacement: "replacement";
+    inbound: "inbound";
+}>;
+export declare const returnShipmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    direction: z.ZodEnum<{
+        replacement: "replacement";
+        inbound: "inbound";
+    }>;
+    deliveryMethodId: z.ZodNullable<z.ZodString>;
+    externalReference: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        received: "received";
+    }>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ReturnShipmentDto = z.infer<typeof returnShipmentSchema>;
+export declare const createReturnShipmentRequestSchema: z.ZodObject<{
+    direction: z.ZodEnum<{
+        replacement: "replacement";
+        inbound: "inbound";
+    }>;
+    deliveryMethodId: z.ZodOptional<z.ZodString>;
+    externalReference: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const reasonAppliesToSchema: z.ZodEnum<{
+    return: "return";
+    complaint: "complaint";
+    both: "both";
+}>;
+export declare const returnReasonSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    appliesTo: z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+        both: "both";
+    }>;
+    isActive: z.ZodBoolean;
+    weight: z.ZodNumber;
+}, z.core.$strip>;
+export type ReturnReasonDto = z.infer<typeof returnReasonSchema>;
+export declare const returnReasonCreateSchema: z.ZodObject<{
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    appliesTo: z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+        both: "both";
+    }>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const returnReasonUpdateSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    appliesTo: z.ZodOptional<z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+        both: "both";
+    }>>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const adminReturnsSortSchema: z.ZodEnum<{
+    "submittedAt:asc": "submittedAt:asc";
+    "submittedAt:desc": "submittedAt:desc";
+    "rmaNumber:asc": "rmaNumber:asc";
+    "rmaNumber:desc": "rmaNumber:desc";
+}>;
+export declare const adminReturnsListQuerySchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        return: "return";
+        complaint: "complaint";
+    }>>;
+    rmaNumber: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        "submittedAt:asc": "submittedAt:asc";
+        "submittedAt:desc": "submittedAt:desc";
+        "rmaNumber:asc": "rmaNumber:asc";
+        "rmaNumber:desc": "rmaNumber:desc";
+    }>>;
+    page: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    pageSize: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type AdminReturnsListQuery = z.infer<typeof adminReturnsListQuerySchema>;
+export declare const adminReturnsListResponseSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        rmaNumber: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            return: "return";
+            complaint: "complaint";
+        }>;
+        orderId: z.ZodString;
+        statusCode: z.ZodString;
+        statusLabel: z.ZodString;
+        totalRefundAmount: z.ZodNumber;
+        currency: z.ZodString;
+        submittedAt: z.ZodString;
+        customerName: z.ZodNullable<z.ZodString>;
+        organizationName: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type AdminReturnsListResponse = z.infer<typeof adminReturnsListResponseSchema>;
+export declare const bulkTransitionRequestSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+    to: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const bulkTransitionResultSchema: z.ZodObject<{
+    moved: z.ZodArray<z.ZodString>;
+    skipped: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BulkTransitionResult = z.infer<typeof bulkTransitionResultSchema>;
+export declare const returnSavedViewSortSchema: z.ZodObject<{
+    field: z.ZodString;
+    dir: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>;
+export declare const returnSavedViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    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.ZodNullable<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ReturnSavedViewDto = z.infer<typeof returnSavedViewSchema>;
+export declare const returnSavedViewCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    shared: z.ZodOptional<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.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const returnSavedViewUpdateSchema: 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.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export interface PaymentRefundInput {
+    orderId: string;
+    amount: number;
+    currency: string;
+    paymentMethodId?: string;
+    /** Idempotency key (the return case id) so retries do not double-refund. */
+    idempotencyKey: string;
+}
+export interface PaymentRefundResult {
+    state: 'issued' | 'pending_manual' | 'failed';
+    externalReference?: string | null;
+    providerDetails?: Record<string, unknown>;
+    failureReason?: string;
+}
+/**
+ * Container name: `paymentRefundPort`. Owner: `payments`.
+ *
+ * The interface through which `returns` asks the payments domain to return
+ * funds. The implementation resolves the order's payment and, where the method
+ * supports an automatic refund, issues it; otherwise it reports
+ * `pending_manual` so an operator settles it out of band (feature 046 FR-035).
+ *
+ * `pending_manual` is the degrade, and it is in the return type rather than in
+ * a caller's `catch` — which is what makes an absent or switched-off gateway
+ * leave the obligation on the platform's books, named, instead of dropping it.
+ */
+export interface PaymentRefundPort {
+    refund(input: PaymentRefundInput): Promise<PaymentRefundResult>;
+}
+/**
+ * A "credit toward future orders" resolution credits the customer's
+ * organisation credit limit, which `credit_limits` already grants and the
+ * checkout credit-check already redeems.
+ *
+ * `applied: false` when the organisation has no credit-limit grant — a
+ * declared outcome, not a failure, so the settlement records the answer rather
+ * than a caller inventing one from a caught error.
+ */
+export interface CreditTopupInput {
+    organizationId: string;
+    amount: number;
+    currency: string;
+    returnCaseId: string;
+}
+export interface CreditTopupResult {
+    applied: boolean;
+    availableAmountAfter?: number;
+}
+/**
+ * Container name: `creditTopupPort`. Owner: `credit_limits`.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `credit_limits` 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 CreditTopupPort {
+    creditFromReturn(input: CreditTopupInput): Promise<CreditTopupResult>;
+}
+export interface OrderReturnContextLine {
+    orderItemId: string;
+    productId: string;
+    name: string;
+    purchasedQty: number;
+    /** Amount paid per unit, including its proportional tax. */
+    paidUnitAmount: number;
+    /** Amount paid for the whole purchased line, including tax. */
+    paidLineAmount: number;
+}
+export interface OrderReturnContext {
+    salesChannelId: string;
+    customerAccountId: string;
+    organizationId: string | null;
+    currency: string;
+    /** When the order entered its fulfilment-completing status; null if it has not. */
+    completingStatusEnteredAt: Date | null;
+    lines: OrderReturnContextLine[];
+}
+/**
+ * Container name: `orderReturnContextPort`. Owner: `orders`.
+ *
+ * The order facts a return needs — paid-per-line amounts, the
+ * fulfilment-completing timestamp, channel, customer, organisation — without
+ * `returns` reading the orders tables (Principle I).
+ *
+ * **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 OrderReturnContextPort {
+    getReturnContext(orderId: string): Promise<OrderReturnContext | null>;
+}
+export interface CorrectiveInvoiceLine {
+    /**
+     * The order item this line credits. It is the link back to the line of the
+     * original invoice being corrected: issuance snapshots `orderItemId` on every
+     * product line, and a return-case item carries the same order item, so the
+     * corrected line's VAT rate can be mirrored rather than assumed (issue #131).
+     */
+    orderItemId: string;
+    productName: string;
+    quantity: number;
+    /** Credited amount for this line, gross (as paid, including its tax). */
+    amount: number;
+}
+export interface CorrectiveInvoiceInput {
+    orderId: string;
+    lines: CorrectiveInvoiceLine[];
+    /** Credited total, gross. */
+    total: number;
+    currency: string;
+    /**
+     * The caller's key for this correction — the return case id (D-91).
+     *
+     * A settlement attempts every external effect **before** it writes any state,
+     * so a refusal from a later step leaves a retryable case behind and the retry
+     * asks for the same correction again. With a key, the second call returns the
+     * document the first one issued; without it, the order carries two corrections
+     * for one return.
+     *
+     * It keys the **return case**, not the order: a second partial return against
+     * the same order is a different case and legitimately gets its own correction.
+     * Omitted, no deduplication is attempted and every call issues a document.
+     */
+    idempotencyKey?: string;
+}
+/** A correction was issued: the document that credits the original invoice. */
+export interface CorrectiveInvoiceIssued {
+    issued: true;
+    invoiceId: string;
+    number: string;
+    status: 'pending' | 'ready' | 'cancelled';
+}
+/**
+ * No correction was due, with the reason (issue #135).
+ *
+ * The settlement caller cannot know whether the order was ever invoiced — the
+ * invoices module can, and answers here. `order_not_invoiced` is the only
+ * reason today: with no original there is no VAT document to correct, so a
+ * correction would be a number, a zero rate and an empty seller/buyer snapshot
+ * standing in for a document that never existed.
+ */
+export interface CorrectiveInvoiceNotDue {
+    issued: false;
+    reason: 'order_not_invoiced';
+}
+export type CorrectiveInvoiceResult = CorrectiveInvoiceIssued | CorrectiveInvoiceNotDue;
+/**
+ * Container name: `correctiveInvoicePort`. Owner: `invoices`.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `invoices` 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 CorrectiveInvoicePort {
+    createCorrection(input: CorrectiveInvoiceInput): Promise<CorrectiveInvoiceResult>;
+}
+//# sourceMappingURL=returns.d.ts.map