@deenruv/core 1.0.0

package/dist/service/services/order-testing.service.js

@@ -0,0 +1,146 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderTestingService = void 0;
+const common_1 = require("@nestjs/common");
+const tax_utils_1 = require("../../common/tax-utils");
+const config_service_1 = require("../../config/config.service");
+const transactional_connection_1 = require("../../connection/transactional-connection");
+const order_entity_1 = require("../../entity/order/order.entity");
+const order_line_entity_1 = require("../../entity/order-line/order-line.entity");
+const product_variant_entity_1 = require("../../entity/product-variant/product-variant.entity");
+const shipping_line_entity_1 = require("../../entity/shipping-line/shipping-line.entity");
+const shipping_method_entity_1 = require("../../entity/shipping-method/shipping-method.entity");
+const config_arg_service_1 = require("../helpers/config-arg/config-arg.service");
+const order_calculator_1 = require("../helpers/order-calculator/order-calculator");
+const product_price_applicator_1 = require("../helpers/product-price-applicator/product-price-applicator");
+const shipping_calculator_1 = require("../helpers/shipping-calculator/shipping-calculator");
+const translator_service_1 = require("../helpers/translator/translator.service");
+/**
+ * @description
+ * This service is responsible for creating temporary mock Orders against which tests can be run, such as
+ * testing a ShippingMethod or Promotion.
+ *
+ * @docsCategory services
+ */
+let OrderTestingService = class OrderTestingService {
+    constructor(connection, orderCalculator, shippingCalculator, configArgService, configService, productPriceApplicator, translator) {
+        this.connection = connection;
+        this.orderCalculator = orderCalculator;
+        this.shippingCalculator = shippingCalculator;
+        this.configArgService = configArgService;
+        this.configService = configService;
+        this.productPriceApplicator = productPriceApplicator;
+        this.translator = translator;
+    }
+    /**
+     * @description
+     * Runs a given ShippingMethod configuration against a mock Order to test for eligibility and resulting
+     * price.
+     */
+    async testShippingMethod(ctx, input) {
+        const shippingMethod = new shipping_method_entity_1.ShippingMethod({
+            checker: this.configArgService.parseInput("ShippingEligibilityChecker", input.checker),
+            calculator: this.configArgService.parseInput("ShippingCalculator", input.calculator),
+        });
+        const mockOrder = await this.buildMockOrder(ctx, input.shippingAddress, input.lines);
+        const eligible = await shippingMethod.test(ctx, mockOrder);
+        const result = eligible
+            ? await shippingMethod.apply(ctx, mockOrder)
+            : undefined;
+        let quote;
+        if (result) {
+            const { price, priceIncludesTax, taxRate, metadata } = result;
+            quote = {
+                price: priceIncludesTax ? (0, tax_utils_1.netPriceOf)(price, taxRate) : price,
+                priceWithTax: priceIncludesTax ? price : (0, tax_utils_1.grossPriceOf)(price, taxRate),
+                metadata,
+            };
+        }
+        return {
+            eligible,
+            quote,
+        };
+    }
+    /**
+     * @description
+     * Tests all available ShippingMethods against a mock Order and return those which are eligible. This
+     * is intended to simulate a call to the `eligibleShippingMethods` query of the Shop API.
+     */
+    async testEligibleShippingMethods(ctx, input) {
+        const mockOrder = await this.buildMockOrder(ctx, input.shippingAddress, input.lines);
+        const eligibleMethods = await this.shippingCalculator.getEligibleShippingMethods(ctx, mockOrder);
+        return eligibleMethods
+            .map((result) => {
+            this.translator.translate(result.method, ctx);
+            return result;
+        })
+            .map((result) => {
+            const { price, taxRate, priceIncludesTax, metadata } = result.result;
+            return {
+                id: result.method.id,
+                price: priceIncludesTax ? (0, tax_utils_1.netPriceOf)(price, taxRate) : price,
+                priceWithTax: priceIncludesTax ? price : (0, tax_utils_1.grossPriceOf)(price, taxRate),
+                name: result.method.name,
+                code: result.method.code,
+                description: result.method.description,
+                metadata: result.result.metadata,
+            };
+        });
+    }
+    async buildMockOrder(ctx, shippingAddress, lines) {
+        const { orderItemPriceCalculationStrategy } = this.configService.orderOptions;
+        const mockOrder = new order_entity_1.Order({
+            lines: [],
+            surcharges: [],
+            modifications: [],
+        });
+        mockOrder.shippingAddress = shippingAddress;
+        for (const line of lines) {
+            const productVariant = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, line.productVariantId, { relations: ["taxCategory"] });
+            await this.productPriceApplicator.applyChannelPriceAndTax(productVariant, ctx, mockOrder);
+            const orderLine = new order_line_entity_1.OrderLine({
+                productVariant,
+                adjustments: [],
+                taxLines: [],
+                quantity: line.quantity,
+                taxCategory: productVariant.taxCategory,
+            });
+            mockOrder.lines.push(orderLine);
+            const { price, priceIncludesTax } = await orderItemPriceCalculationStrategy.calculateUnitPrice(ctx, productVariant, orderLine.customFields || {}, mockOrder, orderLine.quantity);
+            const taxRate = productVariant.taxRateApplied;
+            orderLine.listPrice = price;
+            orderLine.listPriceIncludesTax = priceIncludesTax;
+        }
+        mockOrder.shippingLines = [
+            new shipping_line_entity_1.ShippingLine({
+                listPrice: 0,
+                listPriceIncludesTax: ctx.channel.pricesIncludeTax,
+                taxLines: [],
+                adjustments: [],
+            }),
+        ];
+        await this.orderCalculator.applyPriceAdjustments(ctx, mockOrder, []);
+        return mockOrder;
+    }
+};
+exports.OrderTestingService = OrderTestingService;
+exports.OrderTestingService = OrderTestingService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [transactional_connection_1.TransactionalConnection,
+        order_calculator_1.OrderCalculator,
+        shipping_calculator_1.ShippingCalculator,
+        config_arg_service_1.ConfigArgService,
+        config_service_1.ConfigService,
+        product_price_applicator_1.ProductPriceApplicator,
+        translator_service_1.TranslatorService])
+], OrderTestingService);
+//# sourceMappingURL=order-testing.service.js.map

package/dist/service/services/order-testing.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-testing.service.js","sourceRoot":"","sources":["../../../src/service/services/order-testing.service.ts"],"names":[],"mappings":"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"}

package/dist/service/services/order.service.d.ts

@@ -0,0 +1,432 @@
+import { AddPaymentToOrderResult, ApplyCouponCodeResult, PaymentInput, PaymentMethodQuote, RemoveOrderItemsResult, SetOrderShippingMethodResult, UpdateOrderItemsResult } from "@deenruv/common/lib/generated-shop-types";
+import { AddFulfillmentToOrderResult, AddManualPaymentToOrderResult, AddNoteToOrderInput, CancelOrderInput, CancelOrderResult, CancelPaymentResult, CreateAddressInput, DeletionResponse, FulfillOrderInput, ManualPaymentInput, ModifyOrderInput, ModifyOrderResult, OrderListOptions, OrderProcessState, RefundOrderInput, RefundOrderResult, SetOrderCustomerInput, SettlePaymentResult, SettleRefundInput, ShippingMethodQuote, TransitionPaymentToStateResult, UpdateOrderNoteInput } from "@deenruv/common/lib/generated-types";
+import { ID, PaginatedList } from "@deenruv/common/lib/shared-types";
+import { RequestContext } from "../../api/common/request-context";
+import { RelationPaths } from "../../api/decorators/relations.decorator";
+import { RequestContextCacheService } from "../../cache/request-context-cache.service";
+import { ErrorResultUnion, JustErrorResults } from "../../common/error/error-result";
+import { FulfillmentStateTransitionError, RefundStateTransitionError } from "../../common/error/generated-graphql-admin-errors";
+import { OrderStateTransitionError } from "../../common/error/generated-graphql-shop-errors";
+import { ListQueryOptions } from "../../common/types/common-types";
+import { ConfigService } from "../../config/config.service";
+import { TransactionalConnection } from "../../connection/transactional-connection";
+import { Channel } from "../../entity/channel/channel.entity";
+import { Customer } from "../../entity/customer/customer.entity";
+import { Fulfillment } from "../../entity/fulfillment/fulfillment.entity";
+import { HistoryEntry } from "../../entity/history-entry/history-entry.entity";
+import { Order } from "../../entity/order/order.entity";
+import { OrderLine } from "../../entity/order-line/order-line.entity";
+import { OrderModification } from "../../entity/order-modification/order-modification.entity";
+import { Payment } from "../../entity/payment/payment.entity";
+import { Promotion } from "../../entity/promotion/promotion.entity";
+import { Refund } from "../../entity/refund/refund.entity";
+import { Surcharge } from "../../entity/surcharge/surcharge.entity";
+import { User } from "../../entity/user/user.entity";
+import { EventBus } from "../../event-bus/event-bus";
+import { CustomFieldRelationService } from "../helpers/custom-field-relation/custom-field-relation.service";
+import { FulfillmentState } from "../helpers/fulfillment-state-machine/fulfillment-state";
+import { ListQueryBuilder } from "../helpers/list-query-builder/list-query-builder";
+import { OrderCalculator } from "../helpers/order-calculator/order-calculator";
+import { OrderMerger } from "../helpers/order-merger/order-merger";
+import { OrderModifier } from "../helpers/order-modifier/order-modifier";
+import { OrderState } from "../helpers/order-state-machine/order-state";
+import { OrderStateMachine } from "../helpers/order-state-machine/order-state-machine";
+import { PaymentState } from "../helpers/payment-state-machine/payment-state";
+import { RefundState } from "../helpers/refund-state-machine/refund-state";
+import { RefundStateMachine } from "../helpers/refund-state-machine/refund-state-machine";
+import { ShippingCalculator } from "../helpers/shipping-calculator/shipping-calculator";
+import { TranslatorService } from "../helpers/translator/translator.service";
+import { ChannelService } from "./channel.service";
+import { CountryService } from "./country.service";
+import { CustomerService } from "./customer.service";
+import { FulfillmentService } from "./fulfillment.service";
+import { HistoryService } from "./history.service";
+import { PaymentMethodService } from "./payment-method.service";
+import { PaymentService } from "./payment.service";
+import { ProductVariantService } from "./product-variant.service";
+import { PromotionService } from "./promotion.service";
+import { StockLevelService } from "./stock-level.service";
+import { EntityHydrator } from "../helpers/entity-hydrator/entity-hydrator.service";
+/**
+ * @description
+ * Contains methods relating to {@link Order} entities.
+ *
+ * @docsCategory services
+ */
+export declare class OrderService {
+    private connection;
+    private configService;
+    private productVariantService;
+    private customerService;
+    private countryService;
+    private orderCalculator;
+    private shippingCalculator;
+    private orderStateMachine;
+    private orderMerger;
+    private paymentService;
+    private paymentMethodService;
+    private fulfillmentService;
+    private listQueryBuilder;
+    private refundStateMachine;
+    private historyService;
+    private promotionService;
+    private eventBus;
+    private channelService;
+    private orderModifier;
+    private customFieldRelationService;
+    private requestCache;
+    private translator;
+    private stockLevelService;
+    private entityHydrator;
+    constructor(connection: TransactionalConnection, configService: ConfigService, productVariantService: ProductVariantService, customerService: CustomerService, countryService: CountryService, orderCalculator: OrderCalculator, shippingCalculator: ShippingCalculator, orderStateMachine: OrderStateMachine, orderMerger: OrderMerger, paymentService: PaymentService, paymentMethodService: PaymentMethodService, fulfillmentService: FulfillmentService, listQueryBuilder: ListQueryBuilder, refundStateMachine: RefundStateMachine, historyService: HistoryService, promotionService: PromotionService, eventBus: EventBus, channelService: ChannelService, orderModifier: OrderModifier, customFieldRelationService: CustomFieldRelationService, requestCache: RequestContextCacheService, translator: TranslatorService, stockLevelService: StockLevelService, entityHydrator: EntityHydrator);
+    /**
+     * @description
+     * Returns an array of all the configured states and transitions of the order process. This is
+     * based on the default order process plus all configured {@link OrderProcess} objects
+     * defined in the {@link OrderOptions} `process` array.
+     */
+    getOrderProcessStates(): OrderProcessState[];
+    private restrictOrderJoins;
+    private splitRelations;
+    findAll(ctx: RequestContext, options?: OrderListOptions, relations?: RelationPaths<Order>): Promise<PaginatedList<Order>>;
+    findOne(ctx: RequestContext, orderId: ID, relations?: RelationPaths<Order>): Promise<Order | undefined>;
+    findOneByCode(ctx: RequestContext, orderCode: string, relations?: RelationPaths<Order>): Promise<Order | undefined>;
+    findOneByOrderLineId(ctx: RequestContext, orderLineId: ID, relations?: RelationPaths<Order>): Promise<Order | undefined>;
+    findByCustomerId(ctx: RequestContext, customerId: ID, options?: ListQueryOptions<Order>, relations?: RelationPaths<Order>): Promise<PaginatedList<Order>>;
+    /**
+     * @description
+     * Returns all {@link Payment} entities associated with the Order.
+     */
+    getOrderPayments(ctx: RequestContext, orderId: ID): Promise<Payment[]>;
+    /**
+     * @description
+     * Returns an array of any {@link OrderModification} entities associated with the Order.
+     */
+    getOrderModifications(ctx: RequestContext, orderId: ID): Promise<OrderModification[]>;
+    /**
+     * @description
+     * Returns any {@link Refund}s associated with a {@link Payment}.
+     */
+    getPaymentRefunds(ctx: RequestContext, paymentId: ID): Promise<Refund[]>;
+    getSellerOrders(ctx: RequestContext, order: Order): Promise<Order[]>;
+    getAggregateOrder(ctx: RequestContext, order: Order): Promise<Order | undefined>;
+    getOrderChannels(ctx: RequestContext, order: Order): Promise<Channel[]>;
+    /**
+     * @description
+     * Returns any Order associated with the specified User's Customer account
+     * that is still in the `active` state.
+     */
+    getActiveOrderForUser(ctx: RequestContext, userId: ID): Promise<Order | undefined>;
+    /**
+     * @description
+     * Creates a new, empty Order. If a `userId` is passed, the Order will get associated with that
+     * User's Customer account.
+     */
+    create(ctx: RequestContext, userId?: ID): Promise<Order>;
+    createDraft(ctx: RequestContext): Promise<Order>;
+    private createEmptyOrderEntity;
+    /**
+     * @description
+     * Updates the custom fields of an Order.
+     */
+    updateCustomFields(ctx: RequestContext, orderId: ID, customFields: any): Promise<Order>;
+    /**
+     * @description
+     * Updates the Customer which is assigned to a given Order. The target Customer must be assigned to the same
+     * Channels as the Order, otherwise an error will be thrown.
+     *
+     * @since 2.2.0
+     */
+    updateOrderCustomer(ctx: RequestContext, { customerId, orderId, note }: SetOrderCustomerInput): Promise<Order>;
+    addItemToOrder(ctx: RequestContext, orderId: ID, productVariantId: ID, quantity: number, customFields?: {
+        [key: string]: any;
+    }, relations?: RelationPaths<Order>): Promise<ErrorResultUnion<UpdateOrderItemsResult, Order>>;
+    /**
+     * @description
+     * Adds multiple items to an Order. This method is more efficient than calling `addItemToOrder`
+     * multiple times, as it only needs to fetch the entire Order once, and only performs
+     * price adjustments once at the end.
+     *
+     * Since this method can return multiple error results, it is recommended to check the `errorResults`
+     * array to determine if any errors occurred.
+     *
+     * @since 3.1.0
+     */
+    addItemsToOrder(ctx: RequestContext, orderId: ID, items: Array<{
+        productVariantId: ID;
+        quantity: number;
+        customFields?: {
+            [key: string]: any;
+        };
+    }>, relations?: RelationPaths<Order>): Promise<{
+        order: Order;
+        errorResults: Array<JustErrorResults<UpdateOrderItemsResult>>;
+    }>;
+    /**
+     * @description
+     * Toggles exclusion of a promotion in the Order.
+     */
+    toggleExcludePromotionInOrder(ctx: RequestContext, orderId: ID, promotionId: ID): Promise<Order>;
+    /**
+     * @description
+     * Adjusts the quantity and/or custom field values of an existing OrderLine.
+     *
+     * If you need to adjust multiple OrderLines, use `adjustOrderLines()` instead.
+     */
+    adjustOrderLine(ctx: RequestContext, orderId: ID, orderLineId: ID, quantity: number, customFields?: {
+        [key: string]: any;
+    }, relations?: RelationPaths<Order>): Promise<ErrorResultUnion<UpdateOrderItemsResult, Order>>;
+    adjustOrderLines(ctx: RequestContext, orderId: ID, lines: Array<{
+        orderLineId: ID;
+        quantity: number;
+        customFields?: {
+            [key: string]: any;
+        };
+    }>, relations?: RelationPaths<Order>): Promise<{
+        order: Order;
+        errorResults: Array<JustErrorResults<UpdateOrderItemsResult>>;
+    }>;
+    /**
+     * @description
+     * Removes the specified OrderLine from the Order.
+     *
+     * If you need to remove multiple OrderLines, use `removeItemsFromOrder()` instead.
+     */
+    removeItemFromOrder(ctx: RequestContext, orderId: ID, orderLineId: ID): Promise<ErrorResultUnion<RemoveOrderItemsResult, Order>>;
+    /**
+     * @description
+     * Removes the specified OrderLines from the Order.
+     * This method is more efficient than calling `removeItemFromOrder` multiple times, as it only needs to fetch
+     * the entire Order once, and only performs price adjustments once at the end.
+     *
+     * @since 3.1.0
+     */
+    removeItemsFromOrder(ctx: RequestContext, orderId: ID, orderLineIds: ID[]): Promise<ErrorResultUnion<RemoveOrderItemsResult, Order>>;
+    /**
+     * @description
+     * Removes all OrderLines from the Order.
+     */
+    removeAllItemsFromOrder(ctx: RequestContext, orderId: ID): Promise<ErrorResultUnion<RemoveOrderItemsResult, Order>>;
+    /**
+     * @description
+     * Adds a {@link Surcharge} to the Order.
+     */
+    addSurchargeToOrder(ctx: RequestContext, orderId: ID, surchargeInput: Partial<Omit<Surcharge, "id" | "createdAt" | "updatedAt" | "order">>): Promise<Order>;
+    /**
+     * @description
+     * Removes a {@link Surcharge} from the Order.
+     */
+    removeSurchargeFromOrder(ctx: RequestContext, orderId: ID, surchargeId: ID): Promise<Order>;
+    /**
+     * @description
+     * Applies a coupon code to the Order, which should be a valid coupon code as specified in the configuration
+     * of an active {@link Promotion}.
+     */
+    applyCouponCode(ctx: RequestContext, orderId: ID, couponCode: string): Promise<ErrorResultUnion<ApplyCouponCodeResult, Order>>;
+    /**
+     * @description
+     * Removes a coupon code from the Order.
+     */
+    removeCouponCode(ctx: RequestContext, orderId: ID, couponCode: string): Promise<Order>;
+    /**
+     * @description
+     * Returns all {@link Promotion}s associated with an Order.
+     */
+    getOrderPromotions(ctx: RequestContext, orderId: ID): Promise<Promotion[]>;
+    /**
+     * @description
+     * Returns the next possible states that the Order may transition to.
+     */
+    getNextOrderStates(order: Order): readonly OrderState[];
+    /**
+     * @description
+     * Sets the shipping address for the Order.
+     */
+    setShippingAddress(ctx: RequestContext, orderId: ID, input: CreateAddressInput): Promise<Order>;
+    /**
+     * @description
+     * Sets the billing address for the Order.
+     */
+    setBillingAddress(ctx: RequestContext, orderId: ID, input: CreateAddressInput): Promise<Order>;
+    /**
+     * @description
+     * Returns an array of quotes stating which {@link ShippingMethod}s may be applied to this Order.
+     * This is determined by the configured {@link ShippingEligibilityChecker} of each ShippingMethod.
+     *
+     * The quote also includes a price for each method, as determined by the configured
+     * {@link ShippingCalculator} of each eligible ShippingMethod.
+     */
+    getEligibleShippingMethods(ctx: RequestContext, orderId: ID): Promise<ShippingMethodQuote[]>;
+    /**
+     * @description
+     * Returns an array of quotes stating which {@link PaymentMethod}s may be used on this Order.
+     */
+    getEligiblePaymentMethods(ctx: RequestContext, orderId: ID): Promise<PaymentMethodQuote[]>;
+    /**
+     * @description
+     * Sets the ShippingMethod to be used on this Order.
+     */
+    setShippingMethod(ctx: RequestContext, orderId: ID, shippingMethodIds: ID[]): Promise<ErrorResultUnion<SetOrderShippingMethodResult, Order>>;
+    /**
+     * @description
+     * Transitions the Order to the given state.
+     */
+    transitionToState(ctx: RequestContext, orderId: ID, state: OrderState): Promise<Order | OrderStateTransitionError>;
+    /**
+     * @description
+     * Transitions a Fulfillment to the given state and then transitions the Order state based on
+     * whether all Fulfillments of the Order are shipped or delivered.
+     */
+    transitionFulfillmentToState(ctx: RequestContext, fulfillmentId: ID, state: FulfillmentState): Promise<Fulfillment | FulfillmentStateTransitionError>;
+    /**
+     * @description
+     * Transitions a Refund to the given state
+     */
+    transitionRefundToState(ctx: RequestContext, refundId: ID, state: RefundState, transactionId?: string): Promise<Refund | RefundStateTransitionError>;
+    /**
+     * @description
+     * Allows the Order to be modified, which allows several aspects of the Order to be changed:
+     *
+     * * Changes to OrderLine quantities
+     * * New OrderLines being added
+     * * Arbitrary {@link Surcharge}s being added
+     * * Shipping or billing address changes
+     *
+     * Setting the `dryRun` input property to `true` will apply all changes, including updating the price of the
+     * Order, except history entry and additional payment actions.
+     *
+     * __Using dryRun option, you must wrap function call in transaction manually.__
+     *
+     */
+    modifyOrder(ctx: RequestContext, input: ModifyOrderInput): Promise<ErrorResultUnion<ModifyOrderResult, Order>>;
+    /**
+     * @description
+     * Transitions the given {@link Payment} to a new state. If the order totalWithTax price is then
+     * covered by Payments, the Order state will be automatically transitioned to `PaymentSettled`
+     * or `PaymentAuthorized`.
+     */
+    transitionPaymentToState(ctx: RequestContext, paymentId: ID, state: PaymentState): Promise<ErrorResultUnion<TransitionPaymentToStateResult, Payment>>;
+    /**
+     * @description
+     * Adds a new Payment to the Order. If the Order totalWithTax is covered by Payments, then the Order
+     * state will get automatically transitioned to the `PaymentSettled` or `PaymentAuthorized` state.
+     */
+    addPaymentToOrder(ctx: RequestContext, orderId: ID, input: PaymentInput): Promise<ErrorResultUnion<AddPaymentToOrderResult, Order>>;
+    /**
+     * @description
+     * We can add a Payment to the order if:
+     * 1. the Order is in the `ArrangingPayment` state or
+     * 2. the Order's current state can transition to `PaymentAuthorized` and `PaymentSettled`
+     */
+    private canAddPaymentToOrder;
+    /**
+     * @description
+     * This method is used after modifying an existing completed order using the `modifyOrder()` method. If the modifications
+     * cause the order total to increase (such as when adding a new OrderLine), then there will be an outstanding charge to
+     * pay.
+     *
+     * This method allows you to add a new Payment and assumes the actual processing has been done manually, e.g. in the
+     * dashboard of your payment provider.
+     */
+    addManualPaymentToOrder(ctx: RequestContext, input: ManualPaymentInput): Promise<ErrorResultUnion<AddManualPaymentToOrderResult, Order>>;
+    /**
+     * @description
+     * Settles a payment by invoking the {@link PaymentMethodHandler}'s `settlePayment()` method. Automatically
+     * transitions the Order state if all Payments are settled.
+     */
+    settlePayment(ctx: RequestContext, paymentId: ID): Promise<ErrorResultUnion<SettlePaymentResult, Payment>>;
+    /**
+     * @description
+     * Cancels a payment by invoking the {@link PaymentMethodHandler}'s `cancelPayment()` method (if defined), and transitions the Payment to
+     * the `Cancelled` state.
+     */
+    cancelPayment(ctx: RequestContext, paymentId: ID): Promise<ErrorResultUnion<CancelPaymentResult, Payment>>;
+    /**
+     * @description
+     * Creates a new Fulfillment associated with the given Order and OrderItems.
+     */
+    createFulfillment(ctx: RequestContext, input: FulfillOrderInput): Promise<ErrorResultUnion<AddFulfillmentToOrderResult, Fulfillment>>;
+    private requestedFulfillmentQuantityExceedsLineQuantity;
+    private ensureSufficientStockForFulfillment;
+    /**
+     * @description
+     * Returns an array of all Fulfillments associated with the Order.
+     */
+    getOrderFulfillments(ctx: RequestContext, order: Order): Promise<Fulfillment[]>;
+    /**
+     * @description
+     * Returns an array of all Surcharges associated with the Order.
+     */
+    getOrderSurcharges(ctx: RequestContext, orderId: ID): Promise<Surcharge[]>;
+    /**
+     * @description
+     * Cancels an Order by transitioning it to the `Cancelled` state. If stock is being tracked for the ProductVariants
+     * in the Order, then new {@link StockMovement}s will be created to correct the stock levels.
+     */
+    cancelOrder(ctx: RequestContext, input: CancelOrderInput): Promise<ErrorResultUnion<CancelOrderResult, Order>>;
+    private cancelOrderById;
+    /**
+     * @description
+     * Creates a {@link Refund} against the order and in doing so invokes the `createRefund()` method of the
+     * {@link PaymentMethodHandler}.
+     */
+    refundOrder(ctx: RequestContext, input: RefundOrderInput): Promise<ErrorResultUnion<RefundOrderResult, Refund>>;
+    /**
+     * @description
+     * Settles a Refund by transitioning it to the `Settled` state.
+     */
+    settleRefund(ctx: RequestContext, input: SettleRefundInput): Promise<Refund>;
+    /**
+     * @description
+     * Associates a Customer with the Order.
+     */
+    addCustomerToOrder(ctx: RequestContext, orderIdOrOrder: ID | Order, customer: Customer): Promise<Order>;
+    /**
+     * @description
+     * Creates a new "ORDER_NOTE" type {@link OrderHistoryEntry} in the Order's history timeline.
+     */
+    addNoteToOrder(ctx: RequestContext, input: AddNoteToOrderInput): Promise<Order>;
+    updateOrderNote(ctx: RequestContext, input: UpdateOrderNoteInput): Promise<HistoryEntry>;
+    deleteOrderNote(ctx: RequestContext, id: ID): Promise<DeletionResponse>;
+    /**
+     * @description
+     * Deletes an Order, ensuring that any Sessions that reference this Order are dereferenced before deletion.
+     *
+     * @since 1.5.0
+     */
+    deleteOrder(ctx: RequestContext, orderOrId: ID | Order): Promise<void>;
+    /**
+     * @description
+     * When a guest user with an anonymous Order signs in and has an existing Order associated with that Customer,
+     * we need to reconcile the contents of the two orders.
+     *
+     * The logic used to do the merging is specified in the {@link OrderOptions} `mergeStrategy` config setting.
+     */
+    mergeOrders(ctx: RequestContext, user: User, guestOrder?: Order, existingOrder?: Order): Promise<Order | undefined>;
+    private getOrderOrThrow;
+    private getOrderLineOrThrow;
+    /**
+     * Returns error if quantity is negative.
+     */
+    private assertQuantityIsPositive;
+    /**
+     * Returns error if the Order is not in the "AddingItems" or "Draft" state.
+     */
+    private assertAddingItemsState;
+    /**
+     * Throws if adding the given quantity would take the total order items over the
+     * maximum limit specified in the config.
+     */
+    private assertNotOverOrderItemsLimit;
+    /**
+     * Throws if adding the given quantity would exceed the maximum allowed
+     * quantity for one order line.
+     */
+    private assertNotOverOrderLineItemsLimit;
+    /**
+     * @description
+     * Applies promotions, taxes and shipping to the Order. If the `updatedOrderLines` argument is passed in,
+     * then all of those OrderLines will have their prices re-calculated using the configured {@link OrderItemPriceCalculationStrategy}.
+     */
+    applyPriceAdjustments(ctx: RequestContext, order: Order, updatedOrderLines?: OrderLine[], relations?: RelationPaths<Order>): Promise<Order>;
+}