brinkcommerce-dev-mcp 0.1.0-beta.1

package/dist/clients/order-management-client.js

@@ -0,0 +1,2039 @@
+import { Configuration } from "../generated/order-management/src/runtime.js";
+import { OrdersApi } from "../generated/order-management/src/apis/OrdersApi.js";
+import { CancellationsApi } from "../generated/order-management/src/apis/CancellationsApi.js";
+import { RefundsApi } from "../generated/order-management/src/apis/RefundsApi.js";
+import { ImportsApi } from "../generated/order-management/src/apis/ImportsApi.js";
+import { DeliveriesApi } from "../generated/order-management/src/apis/DeliveriesApi.js";
+import { ReleasesApi } from "../generated/order-management/src/apis/ReleasesApi.js";
+import { CompensationsApi } from "../generated/order-management/src/apis/CompensationsApi.js";
+import { ModificationsApi } from "../generated/order-management/src/apis/ModificationsApi.js";
+import { CustomApi } from "../generated/order-management/src/apis/CustomApi.js";
+import { getAccessToken } from "../auth.js";
+import { logger } from "../logger.js";
+import { handleApiError } from "./error-handler.js";
+/**
+ * Build a StartDeliveryRequest from options
+ */
+function buildStartDeliveryRequest(options) {
+    if (!options) {
+        return {};
+    }
+    const request = {};
+    // Add reason if provided
+    if (options.reasonCode || options.reasonCause) {
+        request.reason = {
+            code: options.reasonCode,
+            cause: options.reasonCause,
+        };
+    }
+    // Add payment action
+    if (options.paymentAction) {
+        if (options.paymentAction === "SKIP") {
+            request.payment = { actionType: "SKIP" };
+        }
+        else if (options.paymentAction === "MANUAL" && options.captureReference) {
+            request.payment = {
+                actionType: "MANUAL",
+                captureReference: options.captureReference,
+            };
+        }
+        else if (options.paymentAction === "AUTO") {
+            request.payment = { actionType: "AUTO" };
+        }
+    }
+    // Add shipping action
+    if (options.shippingAction) {
+        if (options.shippingAction === "SKIP") {
+            request.shipping = { actionType: "SKIP" };
+        }
+        else if (options.shippingAction === "MANUAL" &&
+            options.trackingReference &&
+            options.trackingUrl &&
+            options.shippingMethod) {
+            request.shipping = {
+                actionType: "MANUAL",
+                trackingReference: options.trackingReference,
+                trackingUrl: options.trackingUrl,
+                shippingMethod: options.shippingMethod,
+                shippingCompany: options.shippingCompany,
+            };
+        }
+        else if (options.shippingAction === "AUTO") {
+            request.shipping = { actionType: "AUTO" };
+        }
+    }
+    // Add gift card action
+    if (options.giftCardAction) {
+        if (options.giftCardAction === "SKIP") {
+            request.giftCard = { actionType: "SKIP" };
+        }
+        else if (options.giftCardAction === "AUTO") {
+            request.giftCard = { actionType: "AUTO" };
+        }
+        // MANUAL requires giftCards array which is complex - skip for now
+    }
+    // Add bonus action
+    if (options.bonusAction) {
+        if (options.bonusAction === "SKIP") {
+            request.bonus = { actionType: "SKIP" };
+        }
+        else if (options.bonusAction === "MANUAL" && options.bonusTransactionId) {
+            request.bonus = {
+                actionType: "MANUAL",
+                transactionId: options.bonusTransactionId,
+            };
+        }
+        else if (options.bonusAction === "AUTO") {
+            request.bonus = { actionType: "AUTO" };
+        }
+    }
+    return request;
+}
+/**
+ * Build a StartCancellationRequest from options
+ */
+function buildStartCancellationRequest(options) {
+    if (!options) {
+        return {};
+    }
+    const request = {};
+    // Add payment action
+    if (options.paymentAction) {
+        request.payment = { actionType: options.paymentAction };
+    }
+    // Add gift card action
+    if (options.giftCardAction) {
+        request.giftCard = { actionType: options.giftCardAction };
+    }
+    // Add gift card product action
+    if (options.giftCardProductAction) {
+        request.giftCardProduct = { actionType: options.giftCardProductAction };
+    }
+    // Add bonus action
+    if (options.bonusAction) {
+        request.bonus = { actionType: options.bonusAction };
+    }
+    return request;
+}
+/**
+ * Build a StartRefundRequest from options
+ */
+function buildStartRefundRequest(options) {
+    if (!options) {
+        return {};
+    }
+    const request = {};
+    // Add payment action
+    if (options.paymentAction) {
+        request.payment = { actionType: options.paymentAction };
+    }
+    // Add gift card action
+    if (options.giftCardAction) {
+        request.giftCard = { actionType: options.giftCardAction };
+    }
+    // Add gift card product action
+    if (options.giftCardProductAction) {
+        request.giftCardProduct = { actionType: options.giftCardProductAction };
+    }
+    // Add bonus action
+    if (options.bonusAction) {
+        request.bonus = { actionType: options.bonusAction };
+    }
+    return request;
+}
+/**
+ * Build a StartReleaseRequest from options
+ */
+function buildStartReleaseRequest(options) {
+    if (!options) {
+        return {};
+    }
+    const request = {};
+    // Add payment action
+    if (options.paymentAction) {
+        request.payment = { actionType: options.paymentAction };
+    }
+    // Add gift card action
+    if (options.giftCardAction) {
+        request.giftCard = { actionType: options.giftCardAction };
+    }
+    // Add gift card product action
+    if (options.giftCardProductAction) {
+        request.giftCardProduct = { actionType: options.giftCardProductAction };
+    }
+    // Add bonus action
+    if (options.bonusAction) {
+        request.bonus = { actionType: options.bonusAction };
+    }
+    return request;
+}
+/**
+ * BrinkCommerce Order Management API Client
+ * Wraps the generated client with authentication and error handling
+ */
+export class BrinkOrderManagementClient {
+    ordersApi;
+    cancellationsApi;
+    refundsApi;
+    importsApi;
+    deliveriesApi;
+    releasesApi;
+    compensationsApi;
+    modificationsApi;
+    customApi;
+    apiKey;
+    region;
+    customerName;
+    constructor(config) {
+        this.region = config?.region ?? process.env.BRINK_REGION ?? "eu-west-1";
+        this.customerName = config?.customerName ?? process.env.BRINK_CUSTOMER_NAME ?? "";
+        this.apiKey = config?.apiKey ?? process.env.BRINK_API_KEY ?? "";
+        if (!this.customerName) {
+            throw new Error("BRINK_CUSTOMER_NAME is required");
+        }
+        if (!this.apiKey) {
+            throw new Error("BRINK_API_KEY is required");
+        }
+        // Build base path for Management API
+        const basePath = `https://management.${this.region}.${this.customerName}.brinkcommerce.io/order`;
+        logger.info("Initializing BrinkCommerce Order Management client", {
+            basePath,
+            region: this.region,
+            customerName: this.customerName,
+        });
+        // Create configuration with authentication middleware
+        const configuration = new Configuration({
+            basePath,
+            middleware: [
+                {
+                    pre: async (context) => {
+                        // Determine scope based on HTTP method
+                        // GET/HEAD methods use read scope, others use write scope
+                        const isReadOperation = context.init.method === "GET" || context.init.method === "HEAD";
+                        const scope = isReadOperation
+                            ? "order-management/order:read"
+                            : "order-management/order:write";
+                        // Get OAuth token with appropriate scope
+                        const token = await getAccessToken(scope);
+                        // Add authentication headers
+                        // Note: x-api-key is already set by generated code from xApiKey parameter
+                        const headers = context.init.headers ?? {};
+                        const updatedHeaders = {
+                            ...headers,
+                            Authorization: `Bearer ${token}`,
+                        };
+                        logger.debug("Adding authentication headers to request", {
+                            url: context.url,
+                            method: context.init.method,
+                            scope,
+                        });
+                        // Return updated context with auth headers
+                        return {
+                            url: context.url,
+                            init: {
+                                ...context.init,
+                                headers: updatedHeaders,
+                            },
+                        };
+                    },
+                },
+            ],
+        });
+        // Initialize API clients
+        this.ordersApi = new OrdersApi(configuration);
+        this.cancellationsApi = new CancellationsApi(configuration);
+        this.refundsApi = new RefundsApi(configuration);
+        this.importsApi = new ImportsApi(configuration);
+        this.deliveriesApi = new DeliveriesApi(configuration);
+        this.releasesApi = new ReleasesApi(configuration);
+        this.compensationsApi = new CompensationsApi(configuration);
+        this.modificationsApi = new ModificationsApi(configuration);
+        this.customApi = new CustomApi(configuration);
+    }
+    /**
+     * Get an order by ID
+     *
+     * @param orderId - The order ID to retrieve
+     * @returns Result with order data or error
+     */
+    async getOrder(orderId) {
+        try {
+            logger.info("Getting order", { orderId });
+            const response = await this.ordersApi.getOrder({
+                xApiKey: this.apiKey, // Required by generated code, but auth happens via middleware
+                orderId,
+            });
+            logger.info("Successfully retrieved order", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order");
+        }
+    }
+    /**
+     * Get an order by reference
+     *
+     * @param reference - The order reference
+     * @returns Result with order data or error
+     */
+    async getOrderByReference(reference) {
+        try {
+            logger.info("Getting order by reference", { reference });
+            const response = await this.ordersApi.getOrderByReference({
+                xApiKey: this.apiKey,
+                reference,
+            });
+            logger.info("Successfully retrieved order by reference", { reference });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order by reference");
+        }
+    }
+    /**
+     * Cancel an order
+     *
+     * @param orderId - The order ID to cancel
+     * @param request - Cancellation request data
+     * @returns Result with cancellation details or error
+     */
+    async cancelOrder(orderId, request) {
+        try {
+            logger.info("Creating order cancellation", { orderId });
+            const response = await this.ordersApi.createOrderCancellation({
+                xApiKey: this.apiKey,
+                orderId,
+                cancellationRequest: request,
+            });
+            logger.info("Successfully created order cancellation", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to cancel order");
+        }
+    }
+    /**
+     * Create a refund for an order
+     *
+     * @param orderId - The order ID to refund
+     * @param request - Refund request data
+     * @returns Result with refund details or error
+     */
+    async refundOrder(orderId, request) {
+        try {
+            logger.info("Creating order refund", { orderId });
+            const response = await this.ordersApi.createOrderRefund({
+                xApiKey: this.apiKey,
+                orderId,
+                refundRequest: request,
+            });
+            logger.info("Successfully created order refund", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to refund order");
+        }
+    }
+    /**
+     * Import an external order into BrinkCommerce
+     *
+     * @param importId - The external import ID for this order
+     * @param request - Import order request data
+     * @returns Result with import response or error
+     */
+    async importOrder(importId, request) {
+        try {
+            logger.info("Importing order", { importId });
+            const response = await this.importsApi.importOrder({
+                xApiKey: this.apiKey,
+                importOrderRequest: request,
+            });
+            logger.info("Successfully imported order", { importId, orderId: response.orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to import order");
+        }
+    }
+    /**
+     * Get an imported order by import ID
+     *
+     * @param importId - The import ID to retrieve
+     * @returns Result with order data or error
+     */
+    async getImportedOrder(importId) {
+        try {
+            logger.info("Getting imported order", { importId });
+            const response = await this.importsApi.getImportedOrder({
+                xApiKey: this.apiKey,
+                importId,
+            });
+            logger.info("Successfully retrieved imported order", { importId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get imported order");
+        }
+    }
+    // ==================== DELIVERY OPERATIONS ====================
+    /**
+     * Create a delivery for an order
+     *
+     * @param orderId - The order ID to create delivery for
+     * @param request - Delivery request data
+     * @returns Result with delivery details or error
+     */
+    async createDelivery(orderId, request) {
+        try {
+            logger.info("Creating order delivery", { orderId });
+            const response = await this.deliveriesApi.createOrderDelivery({
+                xApiKey: this.apiKey,
+                orderId,
+                deliveryRequest: request,
+            });
+            logger.info("Successfully created order delivery", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create delivery");
+        }
+    }
+    /**
+     * Get a delivery by ID
+     *
+     * @param deliveryId - The delivery ID to retrieve
+     * @returns Result with delivery data or error
+     */
+    async getDelivery(deliveryId) {
+        try {
+            logger.info("Getting delivery", { deliveryId });
+            const response = await this.deliveriesApi.getDelivery({
+                xApiKey: this.apiKey,
+                deliveryId,
+            });
+            logger.info("Successfully retrieved delivery", { deliveryId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get delivery");
+        }
+    }
+    /**
+     * Update a delivery
+     *
+     * @param deliveryId - The delivery ID to update
+     * @param request - Delivery request data
+     * @returns Result with delivery details or error
+     */
+    async updateDelivery(deliveryId, request) {
+        try {
+            logger.info("Updating delivery", { deliveryId });
+            const response = await this.deliveriesApi.updateDelivery({
+                xApiKey: this.apiKey,
+                deliveryId,
+                deliveryRequest: request,
+            });
+            logger.info("Successfully updated delivery", { deliveryId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to update delivery");
+        }
+    }
+    /**
+     * Delete a delivery
+     *
+     * @param deliveryId - The delivery ID to delete
+     * @returns Result with success or error
+     */
+    async deleteDelivery(deliveryId) {
+        try {
+            logger.info("Deleting delivery", { deliveryId });
+            await this.deliveriesApi.deleteDelivery({
+                xApiKey: this.apiKey,
+                deliveryId,
+            });
+            logger.info("Successfully deleted delivery", { deliveryId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete delivery");
+        }
+    }
+    /**
+     * Start a delivery
+     *
+     * @param deliveryId - The delivery ID to start
+     * @param options - Optional start delivery request options
+     * @returns Result with success or error
+     */
+    async startDelivery(deliveryId, options) {
+        try {
+            logger.info("Starting delivery", { deliveryId, options });
+            const startDeliveryRequest = buildStartDeliveryRequest(options);
+            await this.deliveriesApi.startDelivery({
+                xApiKey: this.apiKey,
+                deliveryId,
+                startDeliveryRequest,
+            });
+            logger.info("Successfully started delivery", { deliveryId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start delivery");
+        }
+    }
+    /**
+     * Restart a delivery
+     *
+     * @param deliveryId - The delivery ID to restart
+     * @param options - Optional start delivery request options
+     * @returns Result with success or error
+     */
+    async restartDelivery(deliveryId, options) {
+        try {
+            logger.info("Restarting delivery", { deliveryId, options });
+            const startDeliveryRequest = buildStartDeliveryRequest(options);
+            await this.deliveriesApi.restartDelivery({
+                xApiKey: this.apiKey,
+                deliveryId,
+                startDeliveryRequest,
+            });
+            logger.info("Successfully restarted delivery", { deliveryId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to restart delivery");
+        }
+    }
+    // ==================== CANCELLATION OPERATIONS ====================
+    /**
+     * Get a cancellation by ID
+     *
+     * @param cancellationId - The cancellation ID to retrieve
+     * @returns Result with cancellation data or error
+     */
+    async getCancellation(cancellationId) {
+        try {
+            logger.info("Getting cancellation", { cancellationId });
+            const response = await this.cancellationsApi.getCancellation({
+                xApiKey: this.apiKey,
+                cancellationId,
+            });
+            logger.info("Successfully retrieved cancellation", { cancellationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get cancellation");
+        }
+    }
+    /**
+     * Delete a cancellation
+     *
+     * @param cancellationId - The cancellation ID to delete
+     * @returns Result with success or error
+     */
+    async deleteCancellation(cancellationId) {
+        try {
+            logger.info("Deleting cancellation", { cancellationId });
+            await this.cancellationsApi.deleteCancellation({
+                xApiKey: this.apiKey,
+                cancellationId,
+            });
+            logger.info("Successfully deleted cancellation", { cancellationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete cancellation");
+        }
+    }
+    /**
+     * Start a cancellation
+     *
+     * @param cancellationId - The cancellation ID to start
+     * @param options - Optional start cancellation request options
+     * @returns Result with success or error
+     */
+    async startCancellation(cancellationId, options) {
+        try {
+            logger.info("Starting cancellation", { cancellationId, options });
+            const startCancellationRequest = buildStartCancellationRequest(options);
+            await this.cancellationsApi.startCancellation({
+                xApiKey: this.apiKey,
+                cancellationId,
+                startCancellationRequest,
+            });
+            logger.info("Successfully started cancellation", { cancellationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start cancellation");
+        }
+    }
+    /**
+     * Restart a cancellation
+     *
+     * @param cancellationId - The cancellation ID to restart
+     * @param options - Optional start cancellation request options
+     * @returns Result with success or error
+     */
+    async restartCancellation(cancellationId, options) {
+        try {
+            logger.info("Restarting cancellation", { cancellationId, options });
+            const startCancellationRequest = buildStartCancellationRequest(options);
+            await this.cancellationsApi.restartCancellation({
+                xApiKey: this.apiKey,
+                cancellationId,
+                startCancellationRequest,
+            });
+            logger.info("Successfully restarted cancellation", { cancellationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to restart cancellation");
+        }
+    }
+    // ==================== REFUND OPERATIONS ====================
+    /**
+     * Get a refund by ID
+     *
+     * @param refundId - The refund ID to retrieve
+     * @returns Result with refund data or error
+     */
+    async getRefund(refundId) {
+        try {
+            logger.info("Getting refund", { refundId });
+            const response = await this.refundsApi.getRefund({
+                xApiKey: this.apiKey,
+                refundId,
+            });
+            logger.info("Successfully retrieved refund", { refundId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get refund");
+        }
+    }
+    /**
+     * Update a refund
+     *
+     * @param refundId - The refund ID to update
+     * @param request - Refund request data
+     * @returns Result with refund details or error
+     */
+    async updateRefund(refundId, request) {
+        try {
+            logger.info("Updating refund", { refundId });
+            const response = await this.refundsApi.updateRefund({
+                xApiKey: this.apiKey,
+                refundId,
+                refundRequest: request,
+            });
+            logger.info("Successfully updated refund", { refundId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to update refund");
+        }
+    }
+    /**
+     * Delete a refund
+     *
+     * @param refundId - The refund ID to delete
+     * @returns Result with success or error
+     */
+    async deleteRefund(refundId) {
+        try {
+            logger.info("Deleting refund", { refundId });
+            await this.refundsApi.deleteRefund({
+                xApiKey: this.apiKey,
+                refundId,
+            });
+            logger.info("Successfully deleted refund", { refundId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete refund");
+        }
+    }
+    /**
+     * Start a refund
+     *
+     * @param refundId - The refund ID to start
+     * @param options - Optional start refund request options
+     * @returns Result with success or error
+     */
+    async startRefund(refundId, options) {
+        try {
+            logger.info("Starting refund", { refundId, options });
+            const startRefundRequest = buildStartRefundRequest(options);
+            await this.refundsApi.startRefund({
+                xApiKey: this.apiKey,
+                refundId,
+                startRefundRequest,
+            });
+            logger.info("Successfully started refund", { refundId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start refund");
+        }
+    }
+    /**
+     * Restart a refund
+     *
+     * @param refundId - The refund ID to restart
+     * @param options - Optional start refund request options
+     * @returns Result with success or error
+     */
+    async restartRefund(refundId, options) {
+        try {
+            logger.info("Restarting refund", { refundId, options });
+            const startRefundRequest = buildStartRefundRequest(options);
+            await this.refundsApi.restartRefund({
+                xApiKey: this.apiKey,
+                refundId,
+                startRefundRequest,
+            });
+            logger.info("Successfully restarted refund", { refundId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to restart refund");
+        }
+    }
+    // ==================== RELEASE OPERATIONS ====================
+    /**
+     * Create a release for an order
+     *
+     * @param orderId - The order ID to create release for
+     * @param request - Release request data
+     * @returns Result with release details or error
+     */
+    async createRelease(orderId, request) {
+        try {
+            logger.info("Creating order release", { orderId });
+            const response = await this.releasesApi.createOrderRelease({
+                xApiKey: this.apiKey,
+                orderId,
+                releaseRequest: request,
+            });
+            logger.info("Successfully created order release", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create release");
+        }
+    }
+    /**
+     * Get a release by ID
+     *
+     * @param releaseId - The release ID to retrieve
+     * @returns Result with release data or error
+     */
+    async getRelease(releaseId) {
+        try {
+            logger.info("Getting release", { releaseId });
+            const response = await this.releasesApi.getRelease({
+                xApiKey: this.apiKey,
+                releaseId,
+            });
+            logger.info("Successfully retrieved release", { releaseId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get release");
+        }
+    }
+    /**
+     * Delete a release
+     *
+     * @param releaseId - The release ID to delete
+     * @returns Result with success or error
+     */
+    async deleteRelease(releaseId) {
+        try {
+            logger.info("Deleting release", { releaseId });
+            await this.releasesApi.deleteRelease({
+                xApiKey: this.apiKey,
+                releaseId,
+            });
+            logger.info("Successfully deleted release", { releaseId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete release");
+        }
+    }
+    /**
+     * Start a release
+     *
+     * @param releaseId - The release ID to start
+     * @param options - Optional start release request options
+     * @returns Result with success or error
+     */
+    async startRelease(releaseId, options) {
+        try {
+            logger.info("Starting release", { releaseId, options });
+            const startReleaseRequest = buildStartReleaseRequest(options);
+            await this.releasesApi.startRelease({
+                xApiKey: this.apiKey,
+                releaseId,
+                startReleaseRequest,
+            });
+            logger.info("Successfully started release", { releaseId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start release");
+        }
+    }
+    /**
+     * Restart a release
+     *
+     * @param releaseId - The release ID to restart
+     * @param options - Optional start release request options
+     * @returns Result with success or error
+     */
+    async restartRelease(releaseId, options) {
+        try {
+            logger.info("Restarting release", { releaseId, options });
+            const startReleaseRequest = buildStartReleaseRequest(options);
+            await this.releasesApi.restartRelease({
+                xApiKey: this.apiKey,
+                releaseId,
+                startReleaseRequest,
+            });
+            logger.info("Successfully restarted release", { releaseId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to restart release");
+        }
+    }
+    // ==================== ORDER QUERY OPERATIONS ====================
+    /**
+     * Get orders by billing address email
+     *
+     * @param email - The email address to search for
+     * @param from - Optional start date filter (RFC3339)
+     * @param to - Optional end date filter (RFC3339)
+     * @returns Result with order summaries or error
+     */
+    async getOrdersByEmail(email, from, to) {
+        try {
+            logger.info("Getting orders by email", { email, from, to });
+            const response = await this.ordersApi.getOrdersByEmail({
+                xApiKey: this.apiKey,
+                email,
+                from,
+                to,
+            });
+            logger.info("Successfully retrieved orders by email", { email, count: response.orderSummaries?.length ?? 0 });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get orders by email");
+        }
+    }
+    /**
+     * Get orders by merchant reference
+     *
+     * @param merchantRef1 - The merchant reference to search for
+     * @param from - Optional start date filter (RFC3339)
+     * @param to - Optional end date filter (RFC3339)
+     * @returns Result with order summaries or error
+     */
+    async getOrdersByMerchantRef(merchantRef1, from, to) {
+        try {
+            logger.info("Getting orders by merchant reference", { merchantRef1, from, to });
+            const response = await this.ordersApi.getOrdersByMerchantReference1({
+                xApiKey: this.apiKey,
+                merchantRef1,
+                from,
+                to,
+            });
+            logger.info("Successfully retrieved orders by merchant reference", { merchantRef1, count: response.orderSummaries?.length ?? 0 });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get orders by merchant reference");
+        }
+    }
+    /**
+     * Get order history (status changes)
+     *
+     * @param orderId - The order ID
+     * @returns Result with order history or error
+     */
+    async getOrderHistory(orderId) {
+        try {
+            logger.info("Getting order history", { orderId });
+            const response = await this.ordersApi.getOrderHistory({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order history", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order history");
+        }
+    }
+    /**
+     * Get order stock reservation
+     *
+     * @param orderId - The order ID
+     * @returns Result with stock reservation data or error
+     */
+    async getOrderReservation(orderId) {
+        try {
+            logger.info("Getting order stock reservation", { orderId });
+            const response = await this.ordersApi.getOrderStockReservation({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order stock reservation", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order stock reservation");
+        }
+    }
+    /**
+     * Delete an order (only orders older than 30 days)
+     *
+     * @param orderId - The order ID to delete
+     * @returns Result with success or error
+     */
+    async deleteOrder(orderId) {
+        try {
+            logger.info("Deleting order", { orderId });
+            await this.ordersApi.deleteOrder({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully deleted order", { orderId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete order");
+        }
+    }
+    // ==================== ORDER COLLECTION OPERATIONS ====================
+    /**
+     * Get all deliveries for an order
+     *
+     * @param orderId - The order ID
+     * @returns Result with order deliveries or error
+     */
+    async getOrderDeliveries(orderId) {
+        try {
+            logger.info("Getting order deliveries", { orderId });
+            const response = await this.ordersApi.getOrderDeliveries({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order deliveries", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order deliveries");
+        }
+    }
+    /**
+     * Get all cancellations for an order
+     *
+     * @param orderId - The order ID
+     * @returns Result with order cancellations or error
+     */
+    async getOrderCancellations(orderId) {
+        try {
+            logger.info("Getting order cancellations", { orderId });
+            const response = await this.ordersApi.getOrderCancellations({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order cancellations", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order cancellations");
+        }
+    }
+    /**
+     * Get all refunds for an order
+     *
+     * @param orderId - The order ID
+     * @returns Result with order refunds or error
+     */
+    async getOrderRefunds(orderId) {
+        try {
+            logger.info("Getting order refunds", { orderId });
+            const response = await this.ordersApi.getOrderRefunds({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order refunds", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order refunds");
+        }
+    }
+    /**
+     * Get all releases for an order
+     *
+     * @param orderId - The order ID
+     * @returns Result with order releases or error
+     */
+    async getOrderReleases(orderId) {
+        try {
+            logger.info("Getting order releases", { orderId });
+            const response = await this.ordersApi.getOrderReleases({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order releases", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order releases");
+        }
+    }
+    /**
+     * Get all compensations for an order
+     *
+     * @param orderId - The order ID
+     * @returns Result with order compensations or error
+     */
+    async getOrderCompensations(orderId) {
+        try {
+            logger.info("Getting order compensations", { orderId });
+            const response = await this.ordersApi.getOrderCompensations({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order compensations", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order compensations");
+        }
+    }
+    /**
+     * Get all modifications for an order
+     *
+     * @param orderId - The order ID
+     * @returns Result with order modifications or error
+     */
+    async getOrderModifications(orderId) {
+        try {
+            logger.info("Getting order modifications", { orderId });
+            const response = await this.ordersApi.getOrderModifications({
+                xApiKey: this.apiKey,
+                orderId,
+            });
+            logger.info("Successfully retrieved order modifications", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order modifications");
+        }
+    }
+    // ==================== COMPENSATION OPERATIONS ====================
+    /**
+     * Create a compensation for an order
+     *
+     * @param orderId - The order ID
+     * @param request - Compensation request data
+     * @returns Result with compensation details or error
+     */
+    async createCompensation(orderId, request) {
+        try {
+            logger.info("Creating order compensation", { orderId });
+            const response = await this.compensationsApi.createOrderCompensation({
+                xApiKey: this.apiKey,
+                orderId,
+                compensationRequest: request,
+            });
+            logger.info("Successfully created order compensation", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create compensation");
+        }
+    }
+    /**
+     * Get a compensation by ID
+     *
+     * @param compensationId - The compensation ID
+     * @returns Result with compensation data or error
+     */
+    async getCompensation(compensationId) {
+        try {
+            logger.info("Getting compensation", { compensationId });
+            const response = await this.compensationsApi.getCompensation({
+                xApiKey: this.apiKey,
+                compensationId,
+            });
+            logger.info("Successfully retrieved compensation", { compensationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get compensation");
+        }
+    }
+    /**
+     * Update a compensation
+     *
+     * @param compensationId - The compensation ID
+     * @param request - Compensation request data
+     * @returns Result with compensation details or error
+     */
+    async updateCompensation(compensationId, request) {
+        try {
+            logger.info("Updating compensation", { compensationId });
+            const response = await this.compensationsApi.updateCompensation({
+                xApiKey: this.apiKey,
+                compensationId,
+                compensationRequest: request,
+            });
+            logger.info("Successfully updated compensation", { compensationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to update compensation");
+        }
+    }
+    /**
+     * Delete a compensation
+     *
+     * @param compensationId - The compensation ID
+     * @returns Result with success or error
+     */
+    async deleteCompensation(compensationId) {
+        try {
+            logger.info("Deleting compensation", { compensationId });
+            await this.compensationsApi.deleteCompensation({
+                xApiKey: this.apiKey,
+                compensationId,
+            });
+            logger.info("Successfully deleted compensation", { compensationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete compensation");
+        }
+    }
+    /**
+     * Start a compensation
+     *
+     * @param compensationId - The compensation ID
+     * @param request - Optional start compensation request
+     * @returns Result with success or error
+     */
+    async startCompensation(compensationId, request) {
+        try {
+            logger.info("Starting compensation", { compensationId });
+            await this.compensationsApi.startCompensation({
+                xApiKey: this.apiKey,
+                compensationId,
+                startCompensationRequest: request,
+            });
+            logger.info("Successfully started compensation", { compensationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start compensation");
+        }
+    }
+    /**
+     * Restart a compensation
+     *
+     * @param compensationId - The compensation ID
+     * @param request - Optional start compensation request
+     * @returns Result with success or error
+     */
+    async restartCompensation(compensationId, request) {
+        try {
+            logger.info("Restarting compensation", { compensationId });
+            await this.compensationsApi.restartCompensation({
+                xApiKey: this.apiKey,
+                compensationId,
+                startCompensationRequest: request,
+            });
+            logger.info("Successfully restarted compensation", { compensationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to restart compensation");
+        }
+    }
+    // ==================== ORDER LINES MODIFICATION OPERATIONS ====================
+    /**
+     * Create an order lines modification
+     *
+     * @param orderId - The order ID
+     * @param request - Order lines modification request
+     * @returns Result with modification details or error
+     */
+    async createOrderLinesModification(orderId, request) {
+        try {
+            logger.info("Creating order lines modification", { orderId });
+            const response = await this.modificationsApi.createOrderLinesModification({
+                xApiKey: this.apiKey,
+                orderId,
+                orderLinesModificationRequest: request,
+            });
+            logger.info("Successfully created order lines modification", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create order lines modification");
+        }
+    }
+    /**
+     * Get an order lines modification by ID
+     *
+     * @param modificationId - The modification ID
+     * @returns Result with modification data or error
+     */
+    async getOrderLinesModification(modificationId) {
+        try {
+            logger.info("Getting order lines modification", { modificationId });
+            const response = await this.modificationsApi.getOrderLinesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+            });
+            logger.info("Successfully retrieved order lines modification", { modificationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get order lines modification");
+        }
+    }
+    /**
+     * Update an order lines modification
+     *
+     * @param modificationId - The modification ID
+     * @param request - Order lines modification request
+     * @returns Result with modification details or error
+     */
+    async updateOrderLinesModification(modificationId, request) {
+        try {
+            logger.info("Updating order lines modification", { modificationId });
+            const response = await this.modificationsApi.updateOrderLinesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+                orderLinesModificationRequest: request,
+            });
+            logger.info("Successfully updated order lines modification", { modificationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to update order lines modification");
+        }
+    }
+    /**
+     * Delete an order lines modification
+     *
+     * @param modificationId - The modification ID
+     * @returns Result with success or error
+     */
+    async deleteOrderLinesModification(modificationId) {
+        try {
+            logger.info("Deleting order lines modification", { modificationId });
+            await this.modificationsApi.deleteOrderLinesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+            });
+            logger.info("Successfully deleted order lines modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete order lines modification");
+        }
+    }
+    /**
+     * Start an order lines modification
+     *
+     * @param modificationId - The modification ID
+     * @param request - Optional start modification request
+     * @returns Result with success or error
+     */
+    async startOrderLinesModification(modificationId, request) {
+        try {
+            logger.info("Starting order lines modification", { modificationId });
+            await this.modificationsApi.startOrderLinesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+                startOrderLinesModificationRequest: request,
+            });
+            logger.info("Successfully started order lines modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start order lines modification");
+        }
+    }
+    /**
+     * Restart an order lines modification
+     *
+     * @param modificationId - The modification ID
+     * @param request - Optional start modification request
+     * @returns Result with success or error
+     */
+    async restartOrderLinesModification(modificationId, request) {
+        try {
+            logger.info("Restarting order lines modification", { modificationId });
+            await this.modificationsApi.restartOrderLinesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+                startOrderLinesModificationRequest: request,
+            });
+            logger.info("Successfully restarted order lines modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to restart order lines modification");
+        }
+    }
+    // ==================== SHIPPING FEES MODIFICATION OPERATIONS ====================
+    /**
+     * Create a shipping fees modification
+     *
+     * @param orderId - The order ID
+     * @param request - Shipping fees modification request
+     * @returns Result with modification details or error
+     */
+    async createShippingFeesModification(orderId, request) {
+        try {
+            logger.info("Creating shipping fees modification", { orderId });
+            const response = await this.modificationsApi.createShippingFeesModification({
+                xApiKey: this.apiKey,
+                orderId,
+                shippingFeesModificationRequest: request,
+            });
+            logger.info("Successfully created shipping fees modification", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create shipping fees modification");
+        }
+    }
+    /**
+     * Get a shipping fees modification by ID
+     *
+     * @param modificationId - The modification ID
+     * @returns Result with modification data or error
+     */
+    async getShippingFeesModification(modificationId) {
+        try {
+            logger.info("Getting shipping fees modification", { modificationId });
+            const response = await this.modificationsApi.getShippingFeesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+            });
+            logger.info("Successfully retrieved shipping fees modification", { modificationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get shipping fees modification");
+        }
+    }
+    /**
+     * Update a shipping fees modification
+     *
+     * @param modificationId - The modification ID
+     * @param request - Shipping fees modification request
+     * @returns Result with modification details or error
+     */
+    async updateShippingFeesModification(modificationId, request) {
+        try {
+            logger.info("Updating shipping fees modification", { modificationId });
+            const response = await this.modificationsApi.updateShippingFeesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+                shippingFeesModificationRequest: request,
+            });
+            logger.info("Successfully updated shipping fees modification", { modificationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to update shipping fees modification");
+        }
+    }
+    /**
+     * Delete a shipping fees modification
+     *
+     * @param modificationId - The modification ID
+     * @returns Result with success or error
+     */
+    async deleteShippingFeesModification(modificationId) {
+        try {
+            logger.info("Deleting shipping fees modification", { modificationId });
+            await this.modificationsApi.deleteShippingFeesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+            });
+            logger.info("Successfully deleted shipping fees modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete shipping fees modification");
+        }
+    }
+    /**
+     * Start a shipping fees modification
+     *
+     * @param modificationId - The modification ID
+     * @param request - Optional start modification request
+     * @returns Result with success or error
+     */
+    async startShippingFeesModification(modificationId, request) {
+        try {
+            logger.info("Starting shipping fees modification", { modificationId });
+            await this.modificationsApi.startShippingFeesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+                startShippingFeesModificationRequest: request,
+            });
+            logger.info("Successfully started shipping fees modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start shipping fees modification");
+        }
+    }
+    /**
+     * Restart a shipping fees modification
+     *
+     * @param modificationId - The modification ID
+     * @param request - Optional start modification request
+     * @returns Result with success or error
+     */
+    async restartShippingFeesModification(modificationId, request) {
+        try {
+            logger.info("Restarting shipping fees modification", { modificationId });
+            await this.modificationsApi.restartShippingFeesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+                startShippingFeesModificationRequest: request,
+            });
+            logger.info("Successfully restarted shipping fees modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to restart shipping fees modification");
+        }
+    }
+    // ==================== ADDRESSES MODIFICATION OPERATIONS ====================
+    /**
+     * Create an order addresses modification
+     *
+     * @param orderId - The order ID
+     * @param request - Order addresses modification request
+     * @returns Result with modification details or error
+     */
+    async createAddressesModification(orderId, request) {
+        try {
+            logger.info("Creating order addresses modification", { orderId });
+            const response = await this.modificationsApi.createOrderAddressesModification({
+                xApiKey: this.apiKey,
+                orderId,
+                orderAddressesModificationRequest: request,
+            });
+            logger.info("Successfully created order addresses modification", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create addresses modification");
+        }
+    }
+    /**
+     * Get an order addresses modification by ID
+     *
+     * @param modificationId - The modification ID
+     * @returns Result with modification data or error
+     */
+    async getAddressesModification(modificationId) {
+        try {
+            logger.info("Getting order addresses modification", { modificationId });
+            const response = await this.modificationsApi.getOrderAddressesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+            });
+            logger.info("Successfully retrieved order addresses modification", { modificationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get addresses modification");
+        }
+    }
+    /**
+     * Update an order addresses modification
+     *
+     * @param modificationId - The modification ID
+     * @param request - Order addresses modification request
+     * @returns Result with modification details or error
+     */
+    async updateAddressesModification(modificationId, request) {
+        try {
+            logger.info("Updating order addresses modification", { modificationId });
+            const response = await this.modificationsApi.updateOrderAddressesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+                orderAddressesModificationRequest: request,
+            });
+            logger.info("Successfully updated order addresses modification", { modificationId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to update addresses modification");
+        }
+    }
+    /**
+     * Delete an order addresses modification
+     *
+     * @param modificationId - The modification ID
+     * @returns Result with success or error
+     */
+    async deleteAddressesModification(modificationId) {
+        try {
+            logger.info("Deleting order addresses modification", { modificationId });
+            await this.modificationsApi.deleteOrderAddressesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+            });
+            logger.info("Successfully deleted order addresses modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete addresses modification");
+        }
+    }
+    /**
+     * Start an order addresses modification
+     *
+     * @param modificationId - The modification ID
+     * @returns Result with success or error
+     */
+    async startAddressesModification(modificationId) {
+        try {
+            logger.info("Starting order addresses modification", { modificationId });
+            await this.modificationsApi.startOrderAddressesModification({
+                xApiKey: this.apiKey,
+                modificationId,
+            });
+            logger.info("Successfully started order addresses modification", { modificationId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to start addresses modification");
+        }
+    }
+    // ==================== CUSTOM STATE OPERATIONS ====================
+    /**
+     * List all custom states
+     *
+     * @returns Result with custom states or error
+     */
+    async listCustomStates() {
+        try {
+            logger.info("Listing custom states");
+            const response = await this.customApi.getCustomStates({
+                xApiKey: this.apiKey,
+            });
+            logger.info("Successfully retrieved custom states");
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to list custom states");
+        }
+    }
+    /**
+     * Get a custom state by ID
+     *
+     * @param stateId - The custom state ID
+     * @returns Result with custom state or error
+     */
+    async getCustomState(stateId) {
+        try {
+            logger.info("Getting custom state", { stateId });
+            const response = await this.customApi.getCustomState({
+                xApiKey: this.apiKey,
+                stateId,
+            });
+            logger.info("Successfully retrieved custom state", { stateId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get custom state");
+        }
+    }
+    /**
+     * Create a custom state
+     *
+     * @param stateId - The custom state ID
+     * @param customState - Custom state data
+     * @returns Result with created custom state or error
+     */
+    async createCustomState(stateId, customState) {
+        try {
+            logger.info("Creating custom state", { stateId });
+            const response = await this.customApi.createCustomState({
+                xApiKey: this.apiKey,
+                stateId,
+                customState,
+            });
+            logger.info("Successfully created custom state", { stateId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create custom state");
+        }
+    }
+    /**
+     * Delete a custom state
+     *
+     * @param stateId - The custom state ID
+     * @returns Result with success or error
+     */
+    async deleteCustomState(stateId) {
+        try {
+            logger.info("Deleting custom state", { stateId });
+            await this.customApi.deleteCustomState({
+                xApiKey: this.apiKey,
+                stateId,
+            });
+            logger.info("Successfully deleted custom state", { stateId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete custom state");
+        }
+    }
+    /**
+     * Add a custom state to an order
+     *
+     * @param orderId - The order ID
+     * @param stateId - The custom state ID
+     * @returns Result with success or error
+     */
+    async addOrderCustomState(orderId, stateId) {
+        try {
+            logger.info("Adding custom state to order", { orderId, stateId });
+            await this.customApi.addOrderCustomState({
+                xApiKey: this.apiKey,
+                orderId,
+                stateId,
+            });
+            logger.info("Successfully added custom state to order", { orderId, stateId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to add custom state to order");
+        }
+    }
+    /**
+     * Remove a custom state from an order
+     *
+     * @param orderId - The order ID
+     * @param stateId - The custom state ID
+     * @returns Result with success or error
+     */
+    async removeOrderCustomState(orderId, stateId) {
+        try {
+            logger.info("Removing custom state from order", { orderId, stateId });
+            await this.customApi.removeOrderCustomState({
+                xApiKey: this.apiKey,
+                orderId,
+                stateId,
+            });
+            logger.info("Successfully removed custom state from order", { orderId, stateId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to remove custom state from order");
+        }
+    }
+    // ==================== CUSTOM REASON CODE OPERATIONS ====================
+    /**
+     * List all custom reason codes
+     *
+     * @returns Result with custom reason codes or error
+     */
+    async listCustomReasonCodes() {
+        try {
+            logger.info("Listing custom reason codes");
+            const response = await this.customApi.getCustomReasonCodes({
+                xApiKey: this.apiKey,
+            });
+            logger.info("Successfully retrieved custom reason codes");
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to list custom reason codes");
+        }
+    }
+    /**
+     * Get a custom reason code
+     *
+     * @param code - The custom reason code
+     * @returns Result with custom reason code or error
+     */
+    async getCustomReasonCode(code) {
+        try {
+            logger.info("Getting custom reason code", { code });
+            const response = await this.customApi.getCustomReasonCode({
+                xApiKey: this.apiKey,
+                code,
+            });
+            logger.info("Successfully retrieved custom reason code", { code });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to get custom reason code");
+        }
+    }
+    /**
+     * Create a custom reason code
+     *
+     * @param code - The custom reason code
+     * @param customReasonCode - Custom reason code data
+     * @returns Result with created custom reason code or error
+     */
+    async createCustomReasonCode(code, customReasonCode) {
+        try {
+            logger.info("Creating custom reason code", { code });
+            const response = await this.customApi.createCustomReasonCode({
+                xApiKey: this.apiKey,
+                code,
+                customReasonCode,
+            });
+            logger.info("Successfully created custom reason code", { code });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create custom reason code");
+        }
+    }
+    /**
+     * Delete a custom reason code
+     *
+     * @param code - The custom reason code
+     * @returns Result with success or error
+     */
+    async deleteCustomReasonCode(code) {
+        try {
+            logger.info("Deleting custom reason code", { code });
+            await this.customApi.deleteCustomReasonCode({
+                xApiKey: this.apiKey,
+                code,
+            });
+            logger.info("Successfully deleted custom reason code", { code });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete custom reason code");
+        }
+    }
+    // ==================== ORDER COMMENT OPERATIONS ====================
+    /**
+     * Create a comment on an order
+     *
+     * @param orderId - The order ID
+     * @param comment - Comment data
+     * @returns Result with order comment or error
+     */
+    async createOrderComment(orderId, comment) {
+        try {
+            logger.info("Creating order comment", { orderId });
+            const response = await this.ordersApi.createOrderComment({
+                xApiKey: this.apiKey,
+                orderId,
+                comment,
+            });
+            logger.info("Successfully created order comment", { orderId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to create order comment");
+        }
+    }
+    /**
+     * Update a comment on an order
+     *
+     * @param orderId - The order ID
+     * @param commentId - The comment ID
+     * @param comment - Updated comment data
+     * @returns Result with order comment or error
+     */
+    async updateOrderComment(orderId, commentId, comment) {
+        try {
+            logger.info("Updating order comment", { orderId, commentId });
+            const response = await this.ordersApi.updateOrderComment({
+                xApiKey: this.apiKey,
+                orderId,
+                commentId,
+                comment,
+            });
+            logger.info("Successfully updated order comment", { orderId, commentId });
+            return {
+                success: true,
+                data: response,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to update order comment");
+        }
+    }
+    /**
+     * Delete a comment from an order
+     *
+     * @param orderId - The order ID
+     * @param commentId - The comment ID
+     * @returns Result with success or error
+     */
+    async deleteOrderComment(orderId, commentId) {
+        try {
+            logger.info("Deleting order comment", { orderId, commentId });
+            await this.ordersApi.deleteOrderComment({
+                xApiKey: this.apiKey,
+                orderId,
+                commentId,
+            });
+            logger.info("Successfully deleted order comment", { orderId, commentId });
+            return {
+                success: true,
+                data: undefined,
+            };
+        }
+        catch (error) {
+            return await handleApiError(error, "Failed to delete order comment");
+        }
+    }
+}
+/**
+ * Factory function to create a BrinkCommerce Order Management client
+ *
+ * @param config - Optional configuration overrides
+ * @returns Configured API client instance
+ */
+export function createOrderManagementClient(config) {
+    return new BrinkOrderManagementClient(config);
+}