@medusajs/order 0.1.0

package/dist/models/shipping-method.js

@@ -0,0 +1,157 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const typeorm_1 = require("typeorm");
+const order_1 = __importDefault(require("./order"));
+const shipping_method_adjustment_1 = __importDefault(require("./shipping-method-adjustment"));
+const shipping_method_tax_line_1 = __importDefault(require("./shipping-method-tax-line"));
+const shippingOptionIdIndex = (0, utils_1.createPsqlIndexStatementHelper)({
+    tableName: "order_shipping_method",
+    columns: "shipping_option_id",
+});
+let ShippingMethod = class ShippingMethod {
+    constructor() {
+        this.description = null;
+        this.is_tax_inclusive = false;
+        this.shipping_option_id = null;
+        this.data = null;
+        this.metadata = null;
+        this.tax_lines = new core_1.Collection(this);
+        this.adjustments = new core_1.Collection(this);
+    }
+    onCreate() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "ordsm");
+        const val = new utils_1.BigNumber(this.raw_amount ?? this.amount);
+        this.amount = val.numeric;
+        this.raw_amount = val.raw;
+    }
+    onUpdate() {
+        const val = new utils_1.BigNumber(this.raw_amount ?? this.amount);
+        this.amount = val.numeric;
+        this.raw_amount = val.raw;
+    }
+    onInit() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "ordsm");
+        const val = new utils_1.BigNumber(this.raw_amount ?? this.amount);
+        this.amount = val.numeric;
+        this.raw_amount = val.raw;
+    }
+};
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], ShippingMethod.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], ShippingMethod.prototype, "order_id", void 0);
+__decorate([
+    (0, core_1.ManyToOne)({
+        entity: () => order_1.default,
+        fieldName: "order_id",
+        index: "IDX_order_shipping_method_order_id",
+        cascade: [core_1.Cascade.REMOVE, core_1.Cascade.PERSIST],
+    }),
+    __metadata("design:type", order_1.default)
+], ShippingMethod.prototype, "order", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], ShippingMethod.prototype, "name", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "description", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "numeric" }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "amount", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb" }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "raw_amount", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "boolean" }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "is_tax_inclusive", void 0);
+__decorate([
+    (0, core_1.Property)({
+        columnType: "text",
+        nullable: true,
+    }),
+    shippingOptionIdIndex.MikroORMIndex(),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "shipping_option_id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "data", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb", nullable: true }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "metadata", void 0);
+__decorate([
+    (0, core_1.OneToMany)(() => shipping_method_tax_line_1.default, (taxLine) => taxLine.shipping_method, {
+        cascade: [core_1.Cascade.REMOVE],
+    }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "tax_lines", void 0);
+__decorate([
+    (0, core_1.OneToMany)(() => shipping_method_adjustment_1.default, (adjustment) => adjustment.shipping_method, {
+        cascade: [core_1.Cascade.REMOVE],
+    }),
+    __metadata("design:type", Object)
+], ShippingMethod.prototype, "adjustments", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], ShippingMethod.prototype, "created_at", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        onUpdate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], ShippingMethod.prototype, "updated_at", void 0);
+__decorate([
+    (0, core_1.BeforeCreate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ShippingMethod.prototype, "onCreate", null);
+__decorate([
+    (0, typeorm_1.BeforeUpdate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ShippingMethod.prototype, "onUpdate", null);
+__decorate([
+    (0, core_1.OnInit)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ShippingMethod.prototype, "onInit", null);
+ShippingMethod = __decorate([
+    (0, core_1.Entity)({ tableName: "order_shipping_method" }),
+    (0, core_1.Check)({ expression: (columns) => `${columns.amount} >= 0` })
+], ShippingMethod);
+exports.default = ShippingMethod;

package/dist/models/tax-line.d.ts

@@ -0,0 +1,17 @@
+import { BigNumberRawValue } from "@medusajs/types";
+import { BigNumber } from "@medusajs/utils";
+/**
+ * As per the Mikro ORM docs, superclasses should use the abstract class definition
+ * Source: https://mikro-orm.io/docs/inheritance-mapping
+ */
+export default abstract class TaxLine {
+    id: string;
+    description?: string | null;
+    tax_rate_id?: string | null;
+    code: string;
+    rate: BigNumber | number;
+    raw_rate: BigNumberRawValue;
+    provider_id?: string | null;
+    created_at: Date;
+    updated_at: Date;
+}

package/dist/models/tax-line.js

@@ -0,0 +1,67 @@
+"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 });
+const core_1 = require("@mikro-orm/core");
+/**
+ * As per the Mikro ORM docs, superclasses should use the abstract class definition
+ * Source: https://mikro-orm.io/docs/inheritance-mapping
+ */
+class TaxLine {
+}
+exports.default = TaxLine;
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], TaxLine.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], TaxLine.prototype, "description", void 0);
+__decorate([
+    (0, core_1.Property)({
+        columnType: "text",
+        nullable: true,
+    }),
+    __metadata("design:type", Object)
+], TaxLine.prototype, "tax_rate_id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], TaxLine.prototype, "code", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "numeric" }),
+    __metadata("design:type", Object)
+], TaxLine.prototype, "rate", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb" }),
+    __metadata("design:type", Object)
+], TaxLine.prototype, "raw_rate", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text", nullable: true }),
+    __metadata("design:type", Object)
+], TaxLine.prototype, "provider_id", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], TaxLine.prototype, "created_at", void 0);
+__decorate([
+    (0, core_1.Property)({
+        onCreate: () => new Date(),
+        onUpdate: () => new Date(),
+        columnType: "timestamptz",
+        defaultRaw: "now()",
+    }),
+    __metadata("design:type", Date)
+], TaxLine.prototype, "updated_at", void 0);

package/dist/module-definition.d.ts

@@ -0,0 +1,2 @@
+import { ModuleExports } from "@medusajs/types";
+export declare const moduleDefinition: ModuleExports;

package/dist/module-definition.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleDefinition = void 0;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const utils_1 = require("@medusajs/utils");
+const Models = __importStar(require("./models"));
+const ModuleModels = __importStar(require("./models"));
+const ModuleRepositories = __importStar(require("./repositories"));
+const ModuleServices = __importStar(require("./services"));
+const _services_1 = require("./services");
+const migrationScriptOptions = {
+    moduleName: modules_sdk_1.Modules.ORDER,
+    models: Models,
+    pathToMigrations: __dirname + "/migrations",
+};
+const runMigrations = utils_1.ModulesSdkUtils.buildMigrationScript(migrationScriptOptions);
+const revertMigration = utils_1.ModulesSdkUtils.buildRevertMigrationScript(migrationScriptOptions);
+const containerLoader = utils_1.ModulesSdkUtils.moduleContainerLoaderFactory({
+    moduleModels: ModuleModels,
+    moduleRepositories: ModuleRepositories,
+    moduleServices: ModuleServices,
+});
+const connectionLoader = utils_1.ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
+    moduleName: modules_sdk_1.Modules.ORDER,
+    moduleModels: Object.values(Models),
+    migrationsPath: __dirname + "/migrations",
+});
+const service = _services_1.OrderModuleService;
+const loaders = [containerLoader, connectionLoader];
+exports.moduleDefinition = {
+    service,
+    loaders,
+    revertMigration,
+    runMigrations,
+};

package/dist/repositories/index.d.ts

@@ -0,0 +1 @@
+export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils";

package/dist/repositories/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRepository = void 0;
+var utils_1 = require("@medusajs/utils");
+Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return utils_1.MikroOrmBaseRepository; } });

package/dist/scripts/bin/run-seed.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+declare const _default: Promise<void>;
+export default _default;

package/dist/scripts/bin/run-seed.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const utils_1 = require("@medusajs/utils");
+const Models = __importStar(require("../../models"));
+const os_1 = require("os");
+const args = process.argv;
+const path = args.pop();
+exports.default = (async () => {
+    const { config } = await Promise.resolve().then(() => __importStar(require("dotenv")));
+    config();
+    if (!path) {
+        throw new Error(`filePath is required.${os_1.EOL}Example: medusa-order-seed <filePath>`);
+    }
+    const run = utils_1.ModulesSdkUtils.buildSeedScript({
+        moduleName: modules_sdk_1.Modules.ORDER,
+        models: Models,
+        pathToMigrations: __dirname + "/../../migrations",
+        seedHandler: async ({ manager, data }) => {
+            // TODO: Add seed logic
+        },
+    });
+    await run({ path });
+})();

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export { default as OrderModuleService } from "./order-module-service";

package/dist/services/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderModuleService = void 0;
+var order_module_service_1 = require("./order-module-service");
+Object.defineProperty(exports, "OrderModuleService", { enumerable: true, get: function () { return __importDefault(order_module_service_1).default; } });

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

@@ -0,0 +1,114 @@
+import { Context, DAL, FilterableLineItemTaxLineProps, IOrderModuleService, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, OrderTypes } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
+import { Address, LineItem, LineItemAdjustment, LineItemTaxLine, Order, ShippingMethod, ShippingMethodAdjustment, ShippingMethodTaxLine } from "../models";
+import { CreateOrderLineItemDTO } from "../types";
+type InjectedDependencies = {
+    baseRepository: DAL.RepositoryService;
+    orderService: ModulesSdkTypes.InternalModuleService<any>;
+    addressService: ModulesSdkTypes.InternalModuleService<any>;
+    lineItemService: ModulesSdkTypes.InternalModuleService<any>;
+    shippingMethodAdjustmentService: ModulesSdkTypes.InternalModuleService<any>;
+    shippingMethodService: ModulesSdkTypes.InternalModuleService<any>;
+    lineItemAdjustmentService: ModulesSdkTypes.InternalModuleService<any>;
+    lineItemTaxLineService: ModulesSdkTypes.InternalModuleService<any>;
+    shippingMethodTaxLineService: ModulesSdkTypes.InternalModuleService<any>;
+};
+declare const OrderModuleService_base: new (container: InjectedDependencies) => ModulesSdkUtils.AbstractModuleService<InjectedDependencies, OrderTypes.OrderDTO, {
+    Address: {
+        dto: OrderTypes.OrderAddressDTO;
+    };
+    LineItem: {
+        dto: OrderTypes.OrderLineItemDTO;
+    };
+    LineItemAdjustment: {
+        dto: OrderTypes.OrderLineItemAdjustmentDTO;
+    };
+    LineItemTaxLine: {
+        dto: OrderTypes.OrderLineItemTaxLineDTO;
+    };
+    ShippingMethod: {
+        dto: OrderTypes.OrderShippingMethodDTO;
+    };
+    ShippingMethodAdjustment: {
+        dto: OrderTypes.OrderShippingMethodAdjustmentDTO;
+    };
+    ShippingMethodTaxLine: {
+        dto: OrderTypes.OrderShippingMethodTaxLineDTO;
+    };
+}>;
+export default class OrderModuleService<TOrder extends Order = Order, TAddress extends Address = Address, TLineItem extends LineItem = LineItem, TLineItemAdjustment extends LineItemAdjustment = LineItemAdjustment, TLineItemTaxLine extends LineItemTaxLine = LineItemTaxLine, TShippingMethodAdjustment extends ShippingMethodAdjustment = ShippingMethodAdjustment, TShippingMethodTaxLine extends ShippingMethodTaxLine = ShippingMethodTaxLine, TShippingMethod extends ShippingMethod = ShippingMethod> extends OrderModuleService_base implements IOrderModuleService {
+    protected readonly moduleDeclaration: InternalModuleDeclaration;
+    protected baseRepository_: DAL.RepositoryService;
+    protected orderService_: ModulesSdkTypes.InternalModuleService<TOrder>;
+    protected addressService_: ModulesSdkTypes.InternalModuleService<TAddress>;
+    protected lineItemService_: ModulesSdkTypes.InternalModuleService<TLineItem>;
+    protected shippingMethodAdjustmentService_: ModulesSdkTypes.InternalModuleService<TShippingMethodAdjustment>;
+    protected shippingMethodService_: ModulesSdkTypes.InternalModuleService<TShippingMethod>;
+    protected lineItemAdjustmentService_: ModulesSdkTypes.InternalModuleService<TLineItemAdjustment>;
+    protected lineItemTaxLineService_: ModulesSdkTypes.InternalModuleService<TLineItemTaxLine>;
+    protected shippingMethodTaxLineService_: ModulesSdkTypes.InternalModuleService<TShippingMethodTaxLine>;
+    constructor({ baseRepository, orderService, addressService, lineItemService, shippingMethodAdjustmentService, shippingMethodService, lineItemAdjustmentService, shippingMethodTaxLineService, lineItemTaxLineService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    __joinerConfig(): ModuleJoinerConfig;
+    create(data: OrderTypes.CreateOrderDTO[], sharedContext?: Context): Promise<OrderTypes.OrderDTO[]>;
+    create(data: OrderTypes.CreateOrderDTO, sharedContext?: Context): Promise<OrderTypes.OrderDTO>;
+    protected create_(data: OrderTypes.CreateOrderDTO[], sharedContext?: Context): Promise<Order[]>;
+    update(data: OrderTypes.UpdateOrderDTO[], sharedContext?: Context): Promise<OrderTypes.OrderDTO[]>;
+    update(data: OrderTypes.UpdateOrderDTO, sharedContext?: Context): Promise<OrderTypes.OrderDTO>;
+    protected update_(data: OrderTypes.UpdateOrderDTO[], sharedContext?: Context): Promise<TOrder[]>;
+    addLineItems(data: OrderTypes.CreateOrderLineItemForOrderDTO): Promise<OrderTypes.OrderLineItemDTO[]>;
+    addLineItems(data: OrderTypes.CreateOrderLineItemForOrderDTO[]): Promise<OrderTypes.OrderLineItemDTO[]>;
+    addLineItems(orderId: string, items: OrderTypes.CreateOrderLineItemDTO[], sharedContext?: Context): Promise<OrderTypes.OrderLineItemDTO[]>;
+    protected addLineItems_(orderId: string, items: OrderTypes.CreateOrderLineItemDTO[], sharedContext?: Context): Promise<LineItem[]>;
+    protected addLineItemsBulk_(data: CreateOrderLineItemDTO[], sharedContext?: Context): Promise<LineItem[]>;
+    updateLineItems(data: OrderTypes.UpdateOrderLineItemWithSelectorDTO[]): Promise<OrderTypes.OrderLineItemDTO[]>;
+    updateLineItems(selector: Partial<OrderTypes.OrderLineItemDTO>, data: OrderTypes.UpdateOrderLineItemDTO, sharedContext?: Context): Promise<OrderTypes.OrderLineItemDTO[]>;
+    updateLineItems(lineItemId: string, data: Partial<OrderTypes.UpdateOrderLineItemDTO>, sharedContext?: Context): Promise<OrderTypes.OrderLineItemDTO>;
+    protected updateLineItem_(lineItemId: string, data: Partial<OrderTypes.UpdateOrderLineItemDTO>, sharedContext?: Context): Promise<LineItem>;
+    protected updateLineItemsWithSelector_(updates: OrderTypes.UpdateOrderLineItemWithSelectorDTO[], sharedContext?: Context): Promise<LineItem[]>;
+    removeLineItems(itemIds: string[], sharedContext?: Context): Promise<void>;
+    removeLineItems(itemIds: string, sharedContext?: Context): Promise<void>;
+    removeLineItems(selector: Partial<OrderTypes.OrderLineItemDTO>, sharedContext?: Context): Promise<void>;
+    createAddresses(data: OrderTypes.CreateOrderAddressDTO, sharedContext?: Context): Promise<OrderTypes.OrderAddressDTO>;
+    createAddresses(data: OrderTypes.CreateOrderAddressDTO[], sharedContext?: Context): Promise<OrderTypes.OrderAddressDTO[]>;
+    protected createAddresses_(data: OrderTypes.CreateOrderAddressDTO[], sharedContext?: Context): Promise<TAddress[]>;
+    updateAddresses(data: OrderTypes.UpdateOrderAddressDTO, sharedContext?: Context): Promise<OrderTypes.OrderAddressDTO>;
+    updateAddresses(data: OrderTypes.UpdateOrderAddressDTO[], sharedContext?: Context): Promise<OrderTypes.OrderAddressDTO[]>;
+    protected updateAddresses_(data: OrderTypes.UpdateOrderAddressDTO[], sharedContext?: Context): Promise<TAddress[]>;
+    addShippingMethods(data: OrderTypes.CreateOrderShippingMethodDTO): Promise<OrderTypes.OrderShippingMethodDTO>;
+    addShippingMethods(data: OrderTypes.CreateOrderShippingMethodDTO[]): Promise<OrderTypes.OrderShippingMethodDTO[]>;
+    addShippingMethods(orderId: string, methods: OrderTypes.CreateOrderShippingMethodForSingleOrderDTO[], sharedContext?: Context): Promise<OrderTypes.OrderShippingMethodDTO[]>;
+    protected addShippingMethods_(orderId: string, data: OrderTypes.CreateOrderShippingMethodForSingleOrderDTO[], sharedContext?: Context): Promise<ShippingMethod[]>;
+    protected addShippingMethodsBulk_(data: OrderTypes.CreateOrderShippingMethodDTO[], sharedContext?: Context): Promise<ShippingMethod[]>;
+    removeShippingMethods(methodIds: string[], sharedContext?: Context): Promise<void>;
+    removeShippingMethods(methodIds: string, sharedContext?: Context): Promise<void>;
+    removeShippingMethods(selector: Partial<OrderTypes.OrderShippingMethodDTO>, sharedContext?: Context): Promise<void>;
+    addLineItemAdjustments(adjustments: OrderTypes.CreateOrderLineItemAdjustmentDTO[]): Promise<OrderTypes.OrderLineItemAdjustmentDTO[]>;
+    addLineItemAdjustments(adjustment: OrderTypes.CreateOrderLineItemAdjustmentDTO): Promise<OrderTypes.OrderLineItemAdjustmentDTO[]>;
+    addLineItemAdjustments(orderId: string, adjustments: OrderTypes.CreateOrderLineItemAdjustmentDTO[], sharedContext?: Context): Promise<OrderTypes.OrderLineItemAdjustmentDTO[]>;
+    setLineItemAdjustments(orderId: string, adjustments: (OrderTypes.CreateOrderLineItemAdjustmentDTO | OrderTypes.UpdateOrderLineItemAdjustmentDTO)[], sharedContext?: Context): Promise<OrderTypes.OrderLineItemAdjustmentDTO[]>;
+    removeLineItemAdjustments(adjustmentIds: string[], sharedContext?: Context): Promise<void>;
+    removeLineItemAdjustments(adjustmentId: string, sharedContext?: Context): Promise<void>;
+    removeLineItemAdjustments(selector: Partial<OrderTypes.OrderLineItemAdjustmentDTO>, sharedContext?: Context): Promise<void>;
+    setShippingMethodAdjustments(orderId: string, adjustments: (OrderTypes.CreateOrderShippingMethodAdjustmentDTO | OrderTypes.UpdateOrderShippingMethodAdjustmentDTO)[], sharedContext?: Context): Promise<OrderTypes.OrderShippingMethodAdjustmentDTO[]>;
+    addShippingMethodAdjustments(adjustments: OrderTypes.CreateOrderShippingMethodAdjustmentDTO[]): Promise<OrderTypes.OrderShippingMethodAdjustmentDTO[]>;
+    addShippingMethodAdjustments(adjustment: OrderTypes.CreateOrderShippingMethodAdjustmentDTO): Promise<OrderTypes.OrderShippingMethodAdjustmentDTO>;
+    addShippingMethodAdjustments(orderId: string, adjustments: OrderTypes.CreateOrderShippingMethodAdjustmentDTO[], sharedContext?: Context): Promise<OrderTypes.OrderShippingMethodAdjustmentDTO[]>;
+    removeShippingMethodAdjustments(adjustmentIds: string[], sharedContext?: Context): Promise<void>;
+    removeShippingMethodAdjustments(adjustmentId: string, sharedContext?: Context): Promise<void>;
+    removeShippingMethodAdjustments(selector: Partial<OrderTypes.OrderShippingMethodAdjustmentDTO>, sharedContext?: Context): Promise<void>;
+    addLineItemTaxLines(taxLines: OrderTypes.CreateOrderLineItemTaxLineDTO[]): Promise<OrderTypes.OrderLineItemTaxLineDTO[]>;
+    addLineItemTaxLines(taxLine: OrderTypes.CreateOrderLineItemTaxLineDTO): Promise<OrderTypes.OrderLineItemTaxLineDTO>;
+    addLineItemTaxLines(orderId: string, taxLines: OrderTypes.CreateOrderLineItemTaxLineDTO[] | OrderTypes.CreateOrderShippingMethodTaxLineDTO, sharedContext?: Context): Promise<OrderTypes.OrderLineItemTaxLineDTO[]>;
+    setLineItemTaxLines(orderId: string, taxLines: (OrderTypes.CreateOrderLineItemTaxLineDTO | OrderTypes.UpdateOrderLineItemTaxLineDTO)[], sharedContext?: Context): Promise<OrderTypes.OrderLineItemTaxLineDTO[]>;
+    removeLineItemTaxLines(taxLineIds: string[], sharedContext?: Context): Promise<void>;
+    removeLineItemTaxLines(taxLineIds: string, sharedContext?: Context): Promise<void>;
+    removeLineItemTaxLines(selector: FilterableLineItemTaxLineProps, sharedContext?: Context): Promise<void>;
+    addShippingMethodTaxLines(taxLines: OrderTypes.CreateOrderShippingMethodTaxLineDTO[]): Promise<OrderTypes.OrderShippingMethodTaxLineDTO[]>;
+    addShippingMethodTaxLines(taxLine: OrderTypes.CreateOrderShippingMethodTaxLineDTO): Promise<OrderTypes.OrderShippingMethodTaxLineDTO>;
+    addShippingMethodTaxLines(orderId: string, taxLines: OrderTypes.CreateOrderShippingMethodTaxLineDTO[] | OrderTypes.CreateOrderShippingMethodTaxLineDTO, sharedContext?: Context): Promise<OrderTypes.OrderShippingMethodTaxLineDTO[]>;
+    setShippingMethodTaxLines(orderId: string, taxLines: (OrderTypes.CreateOrderShippingMethodTaxLineDTO | OrderTypes.UpdateOrderShippingMethodTaxLineDTO)[], sharedContext?: Context): Promise<OrderTypes.OrderShippingMethodTaxLineDTO[]>;
+    removeShippingMethodTaxLines(taxLineIds: string[], sharedContext?: Context): Promise<void>;
+    removeShippingMethodTaxLines(taxLineIds: string, sharedContext?: Context): Promise<void>;
+    removeShippingMethodTaxLines(selector: Partial<OrderTypes.OrderShippingMethodTaxLineDTO>, sharedContext?: Context): Promise<void>;
+}
+export {};