@marteye/studiojs 1.1.36 → 1.1.38

package/dist/index.js

@@ -64,6 +64,9 @@ function SimpleHttpClient(baseUrl, apiKey, fetch, defaultTimeout, debug = false)
         post: async (path, body) => {
             return request("POST", path, body);
         },
+        patch: async (path, body) => {
+            return request("PATCH", path, body);
+        },
         delete: async (path) => {
             return request("DELETE", path);
         },
@@ -71,7 +74,7 @@ function SimpleHttpClient(baseUrl, apiKey, fetch, defaultTimeout, debug = false)
 }
 
 // Path: studiojs/src/resources/markets.ts
-function create$g(_) {
+function create$m(_) {
     const actions = {
         /***
          * This is used to construct the action from the request body
@@ -101,7 +104,7 @@ function create$g(_) {
     return actions;
 }
 
-function create$f(httpClient) {
+function create$l(httpClient) {
     return {
         list: async (marketId) => {
             return httpClient.get(`/${marketId}/adjustments`);
@@ -109,13 +112,59 @@ function create$f(httpClient) {
         get: async (marketId, id) => {
             return httpClient.get(`/${marketId}/adjustments/${id}`);
         },
+        create: async (marketId, data) => {
+            return httpClient.post(`/${marketId}/adjustments`, data);
+        },
+        update: async (marketId, id, data) => {
+            return httpClient.post(`/${marketId}/adjustments/${id}`, data);
+        },
+    };
+}
+
+function create$k(httpClient) {
+    return {
+        /**
+         * Get the full cart for a customer including extras and uninvoiced lots
+         */
+        get: async (marketId, customerId) => {
+            return httpClient.get(`/${marketId}/carts/${customerId}`);
+        },
+        /**
+         * Add an extra product to the customer's cart
+         */
+        addExtra: async (marketId, customerId, data) => {
+            return httpClient.post(`/${marketId}/carts/${customerId}`, data);
+        },
+        /**
+         * Remove an extra from the customer's cart
+         */
+        removeExtra: async (marketId, customerId, itemId) => {
+            return httpClient.delete(`/${marketId}/carts/${customerId}/${itemId}`);
+        },
+    };
+}
+
+function create$j(httpClient) {
+    return {
+        list: async (marketId) => {
+            return httpClient.get(`/${marketId}/extras`);
+        },
+        get: async (marketId, id) => {
+            return httpClient.get(`/${marketId}/extras/${id}`);
+        },
+        create: async (marketId, data) => {
+            return httpClient.post(`/${marketId}/extras`, data);
+        },
+        update: async (marketId, id, data) => {
+            return httpClient.post(`/${marketId}/extras/${id}`, data);
+        },
     };
 }
 
 /***
  * Bidder applications
  */
-function create$e(httpClient) {
+function create$i(httpClient) {
     let applications = {
         /**
          * List applications for a market with optional filtering
@@ -182,7 +231,7 @@ function create$e(httpClient) {
 }
 
 // Path: studiojs/src/resources/markets.ts
-function create$d(httpClient) {
+function create$h(httpClient) {
     let customers = {
         list: async (marketId, lastId) => {
             let params = {};
@@ -200,6 +249,9 @@ function create$d(httpClient) {
         create: async (marketId, customerData) => {
             return httpClient.post(`/${marketId}/customers`, customerData);
         },
+        update: async (marketId, customerId, customerData) => {
+            return httpClient.post(`/${marketId}/customers/${customerId}`, customerData);
+        },
         /**
          * Get a customer by their account number
          * @param marketId - ID of the market the customer belongs to
@@ -5016,7 +5068,7 @@ const uploadSingleFile = async (input, token) => {
 };
 
 // Multipart Upload for Media to the MARTEYE Media Service
-function create$c() {
+function create$g() {
     const files = {
         uploadSingleFile: async (input, token) => {
             return await uploadSingleFile(input, token);
@@ -5031,7 +5083,7 @@ function create$c() {
     return files;
 }
 
-function create$b(httpClient) {
+function create$f(httpClient) {
     const invoices = {
         /**
          * List all invoices for a market with pagination
@@ -5059,7 +5111,7 @@ function create$b(httpClient) {
     return invoices;
 }
 
-function create$a(httpClient) {
+function create$e(httpClient) {
     return {
         create: async (marketId, saleId, lotId, data) => {
             return httpClient.post(`/${marketId}/sales/${saleId}/lots/${lotId}/items`, data);
@@ -5076,7 +5128,7 @@ function create$a(httpClient) {
 /**
  * Defines the possible status values for a lot in a sale
  */
-function create$9(httpClient) {
+function create$d(httpClient) {
     return {
         get: async (marketId, saleId, lotId) => {
             return httpClient.get(`/${marketId}/sales/${saleId}/lots/${lotId}`);
@@ -5096,7 +5148,7 @@ function create$9(httpClient) {
     };
 }
 
-function create$8(httpClient) {
+function create$c(httpClient) {
     const markets = {
         get: async (marketId) => {
             return httpClient.get(`/${marketId}`);
@@ -5118,7 +5170,7 @@ function create$8(httpClient) {
     return markets;
 }
 
-function create$7(httpClient) {
+function create$b(httpClient) {
     const payments = {
         /**
          * List all payments for a market with pagination
@@ -5146,7 +5198,7 @@ function create$7(httpClient) {
     return payments;
 }
 
-function create$6(httpClient) {
+function create$a(httpClient) {
     const payouts = {
         /**
          * List all payouts for a market with pagination
@@ -5174,18 +5226,24 @@ function create$6(httpClient) {
     return payouts;
 }
 
-function create$5(httpClient) {
+function create$9(httpClient) {
     return {
         list: async (marketId) => {
-            return httpClient.get(`/${marketId}/product_codes`);
+            return httpClient.get(`/${marketId}/product-codes`);
         },
         get: async (marketId, id) => {
-            return httpClient.get(`/${marketId}/product_codes/${id}`);
+            return httpClient.get(`/${marketId}/product-codes/${id}`);
+        },
+        create: async (marketId, data) => {
+            return httpClient.post(`/${marketId}/product-codes`, data);
+        },
+        update: async (marketId, id, data) => {
+            return httpClient.post(`/${marketId}/product-codes/${id}`, data);
         },
     };
 }
 
-function create$4(httpClient) {
+function create$8(httpClient) {
     return {
         get: async (marketId, saleId) => {
             return httpClient.get(`/${marketId}/sales/${saleId}`);
@@ -5202,7 +5260,27 @@ function create$4(httpClient) {
     };
 }
 
-function create$3(httpClient) {
+function create$7(httpClient) {
+    return {
+        list: async (marketId) => {
+            return httpClient.get(`/${marketId}/sale-templates`);
+        },
+        get: async (marketId, templateId) => {
+            return httpClient.get(`/${marketId}/sale-templates/${templateId}`);
+        },
+        create: async (marketId, body) => {
+            return httpClient.post(`/${marketId}/sale-templates`, body);
+        },
+        update: async (marketId, templateId, body) => {
+            return httpClient.post(`/${marketId}/sale-templates/${templateId}`, body);
+        },
+        delete: async (marketId, templateId) => {
+            return httpClient.delete(`/${marketId}/sale-templates/${templateId}`);
+        },
+    };
+}
+
+function create$6(httpClient) {
     let search = {
         /**
          * Search for documents within a market
@@ -5217,7 +5295,7 @@ function create$3(httpClient) {
     return search;
 }
 
-function create$2(httpClient) {
+function create$5(httpClient) {
     return {
         get: async (marketId) => {
             return httpClient.get(`/${marketId}/settings`);
@@ -5225,7 +5303,7 @@ function create$2(httpClient) {
     };
 }
 
-function create$1(httpClient) {
+function create$4(httpClient) {
     return {
         list: async (marketId) => {
             return httpClient.get(`/${marketId}/tax_rates`);
@@ -5237,7 +5315,7 @@ function create$1(httpClient) {
 }
 
 // Path: studiojs/src/resources/markets.ts
-function create(_) {
+function create$3(_) {
     const webhooks = {
         /***
          * This is used to construct the webhook event from the request body
@@ -5272,25 +5350,78 @@ function create(_) {
     return webhooks;
 }
 
+function create$2(httpClient) {
+    return {
+        lookup: async (marketId, cph) => httpClient.get(`/${marketId}/cph`, { cph }),
+    };
+}
+
+function create$1(httpClient) {
+    return {
+        list: async (marketId, customerId, params) => {
+            const query = {};
+            if (params === null || params === void 0 ? void 0 : params.lastId)
+                query.lastId = params.lastId;
+            if (params === null || params === void 0 ? void 0 : params.limit)
+                query.limit = params.limit;
+            return httpClient.get(`/${marketId}/customers/${customerId}/contacts`, query);
+        },
+        get: async (marketId, customerId, contactId) => {
+            return httpClient.get(`/${marketId}/customers/${customerId}/contacts/${contactId}`);
+        },
+        create: async (marketId, customerId, payload) => {
+            return httpClient.post(`/${marketId}/customers/${customerId}/contacts`, payload);
+        },
+        update: async (marketId, customerId, contactId, payload) => {
+            return httpClient.post(`/${marketId}/customers/${customerId}/contacts/${contactId}`, payload);
+        },
+        delete: async (marketId, customerId, contactId) => {
+            return httpClient.delete(`/${marketId}/customers/${customerId}/contacts/${contactId}`);
+        },
+    };
+}
+
+function create(httpClient) {
+    let ledger = {
+        /**
+         * Get the current balance for a ledger account
+         * @param marketId - ID of the market
+         * @param account - Full account string (format: owner:accountType:accountName)
+         *                  e.g. "customerId:asset:trade receivable" or "market:liability:trade payable"
+         * @returns The current balance in cents
+         */
+        getBalance: async (marketId, account) => {
+            return httpClient.get(`/${marketId}/ledger/balance`, { account });
+        },
+    };
+    return ledger;
+}
+
 function resources(httpClient) {
     return {
-        markets: create$8(httpClient),
-        sales: create$4(httpClient),
-        lots: create$9(httpClient),
-        lotitems: create$a(httpClient),
-        webhooks: create(),
-        actions: create$g(),
-        bidderApplications: create$e(httpClient),
-        settings: create$2(httpClient),
-        adjustments: create$f(httpClient),
-        productCodes: create$5(httpClient),
-        taxRates: create$1(httpClient),
-        customers: create$d(httpClient),
-        invoices: create$b(httpClient),
-        payments: create$7(httpClient),
-        payouts: create$6(httpClient),
-        search: create$3(httpClient),
-        files: create$c(),
+        markets: create$c(httpClient),
+        sales: create$8(httpClient),
+        lots: create$d(httpClient),
+        lotitems: create$e(httpClient),
+        carts: create$k(httpClient),
+        cph: create$2(httpClient),
+        webhooks: create$3(),
+        actions: create$m(),
+        bidderApplications: create$i(httpClient),
+        settings: create$5(httpClient),
+        adjustments: create$l(httpClient),
+        extras: create$j(httpClient),
+        productCodes: create$9(httpClient),
+        saleTemplates: create$7(httpClient),
+        taxRates: create$4(httpClient),
+        customers: create$h(httpClient),
+        invoices: create$f(httpClient),
+        payments: create$b(httpClient),
+        payouts: create$a(httpClient),
+        search: create$6(httpClient),
+        files: create$g(),
+        contacts: create$1(httpClient),
+        ledger: create(httpClient),
     };
 }
 
@@ -5601,59 +5732,133 @@ EarTag.countryCodes = {
     BE: "056",
 };
 
+/**
+ * Extract the smallest lot number for sorting purposes.
+ * Handles formats:
+ * - Simple: "7" -> 7
+ * - Alpha suffix: "7A" -> 7
+ * - Range: "7-9" -> 7
+ * - Range with alpha: "7A-9A" -> 7
+ * - With gaps: "7-8, 10" -> 7
+ * - Complex: "7A-8A, 10B" -> 7
+ */
+function extractMinLotNumber(lotNumber) {
+    // Handle empty/null
+    if (!lotNumber)
+        return { num: null, alpha: "" };
+    // Split by comma first (handles "7-8, 10" format), flexible with whitespace
+    let segments = lotNumber.split(/\s*,\s*/);
+    let minNum = null;
+    let minAlpha = "";
+    for (let segment of segments) {
+        // Split by hyphen (handles "7-9" range format), flexible with whitespace
+        let rangeParts = segment.split(/\s*-\s*/);
+        for (let part of rangeParts) {
+            // Extract number and alpha from each part (e.g., "7A" -> 7, "A")
+            let match = part.trim().match(/^(\d+)(\D*)$/);
+            if (match) {
+                let num = parseInt(match[1], 10);
+                let alpha = match[2] || "";
+                if (minNum === null ||
+                    num < minNum ||
+                    (num === minNum && alpha < minAlpha)) {
+                    minNum = num;
+                    minAlpha = alpha;
+                }
+            }
+        }
+    }
+    return { num: minNum, alpha: minAlpha };
+}
 function lotComparator(a, b) {
-    const aMatch = a.lotNumber.match(/^(\d+)(\D*)$/);
-    const bMatch = b.lotNumber.match(/^(\d+)(\D*)$/);
-    // If neither matches the pattern, fall back to string comparison
-    if (!aMatch && !bMatch) {
+    let aMin = extractMinLotNumber(a.lotNumber);
+    let bMin = extractMinLotNumber(b.lotNumber);
+    // If neither has numbers, fall back to string comparison
+    if (aMin.num === null && bMin.num === null) {
         return a.lotNumber.localeCompare(b.lotNumber);
     }
-    // If only one matches, the one with numbers comes after
-    if (!aMatch)
+    // If only one has numbers, the one without comes first
+    if (aMin.num === null)
         return -1;
-    if (!bMatch)
+    if (bMin.num === null)
         return 1;
-    // Handle cases with numbers
-    const aNum = parseInt(aMatch[1], 10);
-    const bNum = parseInt(bMatch[1], 10);
-    // Compare numeric parts first
-    if (aNum !== bNum)
-        return aNum - bNum;
-    // Get alphabetic suffixes (or empty string if none)
-    const aAlpha = (aMatch === null || aMatch === void 0 ? void 0 : aMatch[2]) || "";
-    const bAlpha = (bMatch === null || bMatch === void 0 ? void 0 : bMatch[2]) || "";
-    // Compare by length first (shorter comes first)
-    if (aAlpha.length !== bAlpha.length)
-        return aAlpha.length - bAlpha.length;
-    // Then compare alphabetically
-    return aAlpha.localeCompare(bAlpha);
+    // Compare numeric parts
+    if (aMin.num !== bMin.num)
+        return aMin.num - bMin.num;
+    // Compare alpha suffixes by length then alphabetically
+    if (aMin.alpha.length !== bMin.alpha.length) {
+        return aMin.alpha.length - bMin.alpha.length;
+    }
+    return aMin.alpha.localeCompare(bMin.alpha);
 }
 function sortByLotNumber(lots) {
     return [...lots].sort(lotComparator);
 }
 /***
- * Generate the next lot number in a sequence:
+ * Generate the next lot number in a sequence.
+ * Handles various formats:
+ * - Simple: "7" -> "8"
+ * - Alphanumeric: "7A" -> "7B"
+ * - Range: "1-3" -> "4", "1 - 3" -> "4" (flexible whitespace)
+ * - Range with alpha: "1-3A" -> "3B"
+ * - Compound: "1-3, 10" -> "11", "1-5, 7-9" -> "10"
  */
 function nextLotNumber(previousLotNumber) {
-    const match = previousLotNumber.match(/^(\d+)(\D*)$/);
-    if (match) {
-        // Has numeric part
-        const numPart = parseInt(match[1], 10);
-        const alphaPart = match[2];
-        if (alphaPart === "") {
-            // Just a number: 1 -> 2
-            return (numPart + 1).toString();
+    // Helper to compare alpha suffixes (longer = greater, then alphabetically)
+    function isGreaterAlpha(a, b) {
+        let aUpper = a.toUpperCase();
+        let bUpper = b.toUpperCase();
+        if (aUpper.length !== bUpper.length) {
+            return aUpper.length > bUpper.length;
+        }
+        return aUpper > bUpper;
+    }
+    // Split by comma (handles "7-8, 10" format), flexible with whitespace
+    let segments = previousLotNumber.split(/\s*,\s*/);
+    let maxNum = null;
+    let maxAlpha = "";
+    for (let segment of segments) {
+        // Check if segment is a range (contains hyphen with numbers on both sides)
+        // Flexible with whitespace: "1-3", "1 - 3", "1- 3", "1 -3", "1  -3"
+        let rangeMatch = segment.trim().match(/^(\d+)\s*-\s*(\d+)(\D*)$/);
+        if (rangeMatch) {
+            // Range format: take the end number
+            let endNum = parseInt(rangeMatch[2], 10);
+            let alphaPart = rangeMatch[3] || "";
+            if (maxNum === null ||
+                endNum > maxNum ||
+                (endNum === maxNum && isGreaterAlpha(alphaPart, maxAlpha))) {
+                maxNum = endNum;
+                maxAlpha = alphaPart;
+            }
         }
         else {
-            // Alphanumeric: increment the alpha part
-            const nextAlpha = incrementAlphaSequence(alphaPart);
-            return numPart + nextAlpha;
+            // Single value: "7" or "7A"
+            let singleMatch = segment.trim().match(/^(\d+)(\D*)$/);
+            if (singleMatch) {
+                let num = parseInt(singleMatch[1], 10);
+                let alphaPart = singleMatch[2] || "";
+                if (maxNum === null ||
+                    num > maxNum ||
+                    (num === maxNum && isGreaterAlpha(alphaPart, maxAlpha))) {
+                    maxNum = num;
+                    maxAlpha = alphaPart;
+                }
+            }
         }
     }
-    else {
-        // Pure alphabetic: A -> B, Z -> AA, etc.
-        return incrementAlphaSequence(previousLotNumber);
+    // If we found numeric parts, increment
+    if (maxNum !== null) {
+        if (maxAlpha === "") {
+            return (maxNum + 1).toString();
+        }
+        else {
+            let nextAlpha = incrementAlphaSequence(maxAlpha);
+            return maxNum + nextAlpha;
+        }
     }
+    // Fallback: treat as pure alphabetic (e.g., "A" -> "B")
+    return incrementAlphaSequence(previousLotNumber);
 }
 function incrementAlphaSequence(alpha) {
     if (alpha === "") {