data-science-document-ai 1.13.0__py3-none-any.whl → 1.56.1__py3-none-any.whl

src/postprocessing/postprocess_partner_invoice.py

@@ -1,60 +1,416 @@
 """This module contains the postprocessing functions for the partner invoice."""
-from src.postprocessing.common import extract_string
+from collections import defaultdict
+
+from rapidfuzz import fuzz, process
+
+from src.io import logger
+from src.utils import get_tms_mappings
 
 
 def postprocessing_partner_invoice(partner_invoice):
     """Apply postprocessing to the partner invoice data."""
-    # flatten the invoice amount
+    # Flatten the invoice amount
     for amount in partner_invoice.get("invoiceAmount", {}):
         if isinstance(amount, list):
             amount = amount[0]
         if isinstance(amount, dict):
-            for amount_key, val in amount.items():
-                partner_invoice[f"invoiceAmount_{amount_key}"] = val
+            partner_invoice.update(amount)
             break
-    # remove invoiceAmount -comes from doc ai-
-    partner_invoice.pop("invoiceAmount")
-    # remove containers -comes from doc ai-
-    partner_invoice.pop("containers")
 
-    # some datapoints marked as optional multiple
-    # these are optional multiple for the 'collective invoices' not for the single ones
-    # make sure that we send only one item, collective invoices will handled by llms
-    optional_multiple_list = ["dueDate", "eta", "etd", "fortoEntity", "hblNumber"]
+    # Remove invoiceAmount - comes from DocAI
+    if partner_invoice.get("invoiceAmount") is not None:
+        partner_invoice.pop("invoiceAmount")
+
+    # Remove containers - comes from DocAI
+    # TODO: we can distribute containers to line items based on location proximity
+    if partner_invoice.get("containers") is not None:
+        partner_invoice.pop("containers")
 
+    # Ensure only one item for optional multiple fields
+    optional_multiple_list = [
+        "dueDate",
+        "eta",
+        "etd",
+        "fortoEntity",
+        "hblNumber",
+        "reverseChargeSentence",
+    ]
     for k, v in partner_invoice.items():
         if (k in optional_multiple_list) and isinstance(v, list):
             partner_invoice[k] = v[0]
 
+    # Update keys
     key_updates = {
-        'pod': 'portOfDischarge',
-        'pol': 'portOfLoading',
-        'containerSize': 'containerType',
-        'invoiceAmount_currencyCode': 'currencyCode',
-        'invoiceAmount_grandTotal': 'grandTotal',
-        'invoiceAmount_vatAmount': 'vatAmount',
-        'invoiceAmount_vatApplicableAmount': 'totalAmountGross',
-        'invoiceAmount_vatPercentage': 'vatPercentage',
-        'name': 'lineItemDescription',
-        'unit': 'quantity'
-        }
+        "pod": "portOfDischarge",
+        "pol": "portOfLoading",
+        "name": "lineItemDescription",
+        "unit": "quantity",
+    }
 
     def update_keys(d, key_updates):
         """
         Recursively updates keys in a dictionary according to a mapping provided in key_updates.
-        
+
         d: The original dictionary
         key_updates: A dictionary mapping old key names to new key names
-        
+
         return A new dictionary with updated key names
         """
         if isinstance(d, dict):
-            return {key_updates.get(k, k): update_keys(v, key_updates) for k, v in d.items()}
+            return {
+                key_updates.get(k, k): update_keys(v, key_updates) for k, v in d.items()
+            }
         elif isinstance(d, list):
             return [update_keys(item, key_updates) for item in d]
         else:
             return d
 
     updated_data = update_keys(partner_invoice, key_updates)
-
     return updated_data
+
+
+def post_process_bundeskasse(aggregated_data):
+    """Post-process the Bundeskasse invoice data."""
+    # Check if the Credit note number starts with ATS and classify it to Credit Note else Invoice
+    invoice_type = (
+        "bundeskasseCreditNote"
+        if aggregated_data.get("creditNoteInvoiceNumber", {})
+        .get("documentValue", "")
+        .startswith("ATS")
+        else "bundeskasseInvoice"
+    )
+
+    aggregated_data["documentType"] = {
+        "documentValue": invoice_type,
+        "formattedValue": invoice_type,
+    }
+
+    # Predefine mappings for tax codes
+    tax_type_mappings = {
+        "A0000": "Zölle (ohne EGKS-Zölle, Ausgleichs-, Antidumping- und Zusatzzölle, Zölle auf Agrarwaren) (ZOLLEU)",
+        "B0000": "Einfuhrumsatzsteuer(EUSt)",
+        "A3000": "Endgültige Antidumpingzölle(ANTIDUMPEU)",
+    }
+
+    line_items = aggregated_data.get("lineItem", [])
+    is_recipient_forto = False  # Check if Forto account is in any line item
+
+    # Process each line item
+    for line_item in line_items:
+        tax_type = line_item.get("taxType")
+        if tax_type:
+            # Map the tax type to the corresponding value
+            line_item["name"]["formattedValue"] = tax_type_mappings.get(
+                tax_type.get("documentValue"), line_item["name"]["documentValue"]
+            )
+
+        # Check if the deferredDutyPayer is forto
+        KEYWORDS = {"de789147263644738", "forto", "009812"}
+
+        def is_forto_recipient(line_item: dict) -> bool:
+            values_to_check = [
+                line_item.get("deferredDutyPayer", {}).get("documentValue", ""),
+                line_item.get("vatId", {}).get("documentValue", ""),
+            ]
+
+            combined = " ".join(values_to_check).lower()
+            return any(keyword in combined for keyword in KEYWORDS)
+
+        if is_forto_recipient(line_item):
+            is_recipient_forto = True
+
+    update_recipient_and_vendor(aggregated_data, is_recipient_forto)
+
+
+def update_recipient_and_vendor(aggregated_data, is_recipient_forto):
+    """Update the recipient and vendor information in the aggregated data."""
+    # Check if the "recipientName" and "recipientAddress" keys exist
+    keys_to_init = ["recipientName", "recipientAddress", "vendorName", "vendorAddress"]
+    for key in keys_to_init:
+        aggregated_data.setdefault(key, {"formattedValue": "", "documentValue": ""})
+
+    if is_recipient_forto:
+        # Update the aggregated data with the recipient information
+        aggregated_data["recipientName"][
+            "formattedValue"
+        ] = "Forto Logistics SE & Co KG"
+        aggregated_data["recipientAddress"][
+            "formattedValue"
+        ] = "Schönhauser Allee 9, 10119 Berlin, Germany"
+
+    # Update the vendor details always to Bundeskasse Trier
+    aggregated_data["vendorName"]["formattedValue"] = "Bundeskasse Trier"
+    aggregated_data["vendorAddress"][
+        "formattedValue"
+    ] = "Dasbachstraße 15, 54292 Trier, Germany"
+
+
+def select_unique_bank_account(bank_account):
+    # Select the unique bank account if multiple are present
+    if isinstance(bank_account, list) and bank_account:
+        best = defaultdict(lambda: None)
+
+        for item in bank_account:
+            dv = item["documentValue"]
+            if best[dv] is None or item["page"] < best[dv]["page"]:
+                best[dv] = item
+
+        unique = list(best.values())
+        return unique
+
+
+async def process_partner_invoice(params, aggregated_data, document_type_code):
+    """Process the partner invoice data."""
+    # Post process bundeskasse invoices
+    if document_type_code == "bundeskasse":
+        post_process_bundeskasse(aggregated_data)
+        return
+
+    if "bankAccount" in aggregated_data:
+        aggregated_data["bankAccount"] = select_unique_bank_account(
+            aggregated_data["bankAccount"]
+        )
+
+    line_items = aggregated_data.get("lineItem", [])
+    # Add debug logging
+    logger.info(f"Processing partnerInvoice with {len(line_items)} line items")
+
+    reverse_charge = None
+    reverse_charge_info = aggregated_data.get("reverseChargeSentence")
+
+    # Check if reverseChargeSentence exists and has the expected structure
+    if isinstance(reverse_charge_info, dict):
+        # Get the reverse charge sentence and Check if the reverse charge sentence is present
+        rev_charge_sentence = reverse_charge_info.get("formattedValue", "")
+        reverse_charge_value = if_reverse_charge_sentence(rev_charge_sentence, params)
+
+        # Assign the reverse charge value to the aggregated data
+        reverse_charge_info["formattedValue"] = reverse_charge_value
+        reverse_charge = aggregated_data.pop("reverseChargeSentence", None)
+
+    # Partner Name
+    partner_name = aggregated_data.get("vendorName", {}).get("documentValue", None)
+
+    # Process everything in one go
+    processed_items = await process_line_items_batch(
+        params, line_items, reverse_charge, partner_name
+    )
+
+    # Update your main data structure
+    aggregated_data["lineItem"] = processed_items
+
+
+async def process_line_items_batch(
+    params: dict, line_items: list[dict], reverse_charge=None, partner_name=None
+):
+    """
+    Processes all line items efficiently using a "Split-Apply-Combine" strategy.
+    """
+    # To store items that need external API lookup
+    pending_line_items = {}
+
+    # Check Fuzzy Matching
+    logger.info(f"Mapping line item codes with Fuzzy matching....")
+    for i, item in enumerate(line_items):
+        description_obj = item.get("lineItemDescription")
+
+        if not description_obj or not description_obj.get("formattedValue"):
+            continue
+        # Get the formatted description text
+        desc = description_obj["formattedValue"]
+
+        # Find Fuzzy Match
+        matched_code = find_matching_lineitem(
+            desc,
+            params["lookup_data"]["item_code"],
+            params["fuzzy_threshold_item_code"],
+        )
+
+        if matched_code:
+            # Set the code to the line item
+            item["itemCode"] = {
+                "documentValue": desc,
+                "formattedValue": matched_code,
+                "page": description_obj.get("page"),
+            }
+        else:
+            # Store for batch API call
+            pending_line_items[i] = desc
+
+    # Batch API Call for Embedding lookups
+    if pending_line_items:
+        code_map = await fetch_line_item_codes(pending_line_items, partner_name, params)
+
+        for index, desc in pending_line_items.items():
+            line_items[index]["itemCode"] = {
+                "documentValue": desc,
+                "formattedValue": code_map.get(desc),
+                "page": line_items[index]["lineItemDescription"].get("page"),
+            }
+
+    # Add reverse charge here if exists
+    if reverse_charge:
+        [
+            item.update({"reverseChargeSentence": reverse_charge})
+            for item in line_items
+            if (
+                (item.get("itemCode") and item["itemCode"]["formattedValue"] != "CDU")
+                or not item.get("itemCode")
+            )
+        ]
+
+    return line_items
+
+
+def get_fuzzy_match_score(target: str, sentences: list, threshold: int):
+    """Get the best fuzzy match for a target string from a list of candidates.
+
+    Args:
+        target (str): The string to match.
+        sentences (list): List of strings to match against.
+        threshold (int): Minimum score threshold to consider a match.
+
+    Returns:
+        tuple: (best_match, score) if above threshold, else (None, 0)
+    """
+    # Use multiprocessing to find the best match
+    result = process.extractOne(
+        target, sentences, scorer=fuzz.WRatio, score_cutoff=threshold
+    )
+
+    if result is None:
+        return None, False
+
+    match, score, index = result
+
+    # return best_match if the best match score is above a threshold (e.g., 80)
+    if match:
+        return match, True
+
+    return None, False
+
+
+def if_reverse_charge_sentence(sentence: str, params):
+    """Check if the reverse charge sentence is present in the line item."""
+    reverse_charge_sentences = params["lookup_data"]["reverse_charge_sentences"]
+    threshold = params["fuzzy_threshold_reverse_charge"]
+
+    # Check if ("ARTICLE 144", "ART. 144") in the sentence
+    if "ARTICLE 144" in sentence or "ART 144" in sentence:
+        return False
+
+    # Check if the sentence is similar to any of the reverse charge sentences
+    match, _ = get_fuzzy_match_score(
+        sentence, list(reverse_charge_sentences.keys()), threshold
+    )
+
+    if match:
+        return reverse_charge_sentences[match]
+
+    return False
+
+
+def find_matching_lineitem(new_lineitem: str, kvp_dict: dict, threshold=90):
+    """Find the best matching line item from the key-value pair dictionary using fuzzy matching.
+
+    Args:
+        new_lineitem (str): The new line item to be matched.
+        kvp_dict (dict): The key-value pair dictionary with 'Processed Lineitem' as key and 'Forto SLI' as value.
+        threshold (int): Minimum score threshold to consider a match.
+    Returns:
+        str: The best matching 'Forto SLI' value from the dictionary.
+    """
+    # Check if the new line item is already in the dictionary
+    if new_lineitem in kvp_dict:
+        return kvp_dict[new_lineitem]
+
+    # Get the best fuzzy match score for the extracted line item
+    match, _ = get_fuzzy_match_score(
+        new_lineitem,
+        list(kvp_dict.keys()),
+        threshold,
+    )
+
+    if match:
+        # find the code from the kvp_dict
+        return kvp_dict[match]
+
+    return None
+
+
+async def associate_forto_item_code(line_item_data, params, partner_name=None):
+    """
+    Associates Forto item codes to a list of line item descriptions.
+    Args:
+        line_item_data (dict): A dictionary where keys are original descriptions and values are cleaned descriptions.
+        params (dict): Parameters containing lookup data and thresholds.
+        partner_name (str, optional): The name of the partner for context in matching. Defaults to None.
+
+    Returns:
+        list: A list of dictionaries with 'description' and 'itemCode' keys.
+    """
+
+    result = []
+    pending_line_items = {}
+    for desc, f_desc in line_item_data.items():
+        # Get the Forto item code using fuzzy matching
+        code = find_matching_lineitem(
+            new_lineitem=f_desc,
+            kvp_dict=params["lookup_data"]["item_code"],
+            threshold=params["fuzzy_threshold_item_code"],
+        )
+        if code:
+            result.append({"description": desc, "itemCode": code})
+        else:
+            pending_line_items[desc] = f_desc
+
+    # Batch API Call for Embedding lookups
+    if pending_line_items:
+        code_map = await fetch_line_item_codes(pending_line_items, partner_name, params)
+
+        for desc, f_desc in pending_line_items.items():
+            result.append(
+                {
+                    "description": desc,
+                    "itemCode": code_map.get(f_desc),
+                }
+            )
+
+    return result
+
+
+async def fetch_line_item_codes(
+    pending_line_items: dict,
+    partner_name: str | None,
+    params: dict,
+):
+    """Returns: {original_description: mapped_code_or_None}"""
+    t_mode = (
+        find_matching_lineitem(
+            partner_name.upper(),
+            params["lookup_data"]["intermodal_partners"],
+            threshold=87,
+        )
+        if partner_name
+        else None
+    )
+
+    unique_descs = list(set(pending_line_items.values()))
+    logger.info(f"Mapping {len(unique_descs)} line items from Embedding API...")
+
+    # Build API input map
+    api_input_map = {
+        desc: f"{t_mode} - {desc}" if t_mode else desc for desc in unique_descs
+    }
+
+    api_results = await get_tms_mappings(
+        input_list=list(api_input_map.values()),
+        embedding_type="line_items",
+    )
+
+    # Normalize response back to original descriptions
+    result = {
+        original_desc: api_results.get(api_desc)
+        for original_desc, api_desc in api_input_map.items()
+    }
+    return result

src/prompts/library/arrivalNotice/other/placeholders.json

@@ -0,0 +1,70 @@
+{
+  "type": "OBJECT",
+  "properties": {
+      "bookingNumber": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The booking number associated with the Arrival Notice document. They are often referred to as 'Booking Number', 'Booking No.', 'Booking Ref.', 'Booking Reference', 'Booking ID', 'carrier's reference' or 'Order Ref'."
+      },
+      "destinationTerminal": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The terminal at the destination port where the container will be delivered."
+      },
+      "eta": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "Estimated Time of Arrival (ETA) is the expected date when the shipment will arrive at its destination."
+      },
+      "mblNumber": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "Bill of Lading number (B/L NO.), a document issued by the carrier."
+      },
+      "portOfDischarge": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The port where the goods are discharged from the vessel. This is the destination port for the shipment."
+      },
+      "vesselName": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The name of the vessel carrying the shipment."
+      },
+      "containers": {
+          "type": "ARRAY",
+          "items": {
+              "type": "OBJECT",
+              "properties": {
+                  "containerNumber": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The unique identifier for each container. It always starts with 4 capital letters and followed by 7 digits. Example: TEMU7972458."
+                  },
+                  "containerType": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The size of the container associated with the containerNumber, such as 20ft, 40ft, 40HC, 20DC etc."
+                  },
+                  "grossWeight": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The gross weight of the container. Usually mentioned as G.W or GW or Gross Weight, etc.."
+                  },
+                  "measurements": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The volume of the container. Usually, it is measured in 'Cubic Meter (cbm)' or dimensions. But volume in 'cbm' is preferred."
+                  },
+                  "sealNumber": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The seal number associated with the container Number. But it is not same as the container number."
+                  }
+              },
+              "required": ["containerNumber", "containerType", "grossWeight"]
+          }
+      }
+},
+  "required": ["bookingNumber", "destinationTerminal", "eta", "portOfDischarge", "vesselName", "containers"]
+}

src/prompts/library/arrivalNotice/other/prompt.txt

@@ -0,0 +1,40 @@
+<PERSONA> You are an efficient document entity data extraction specialist working for a Freight Forwarding company. <PERSONA>
+
+<TASK> Your task is to extract data from Arrival Notice documents as per the given response schema structure. <TASK>
+
+<CONTEXT>
+The Freight Forwarding company receives Arrival Notice from shipping lines.
+These documents contain various details related to arrival of a shipment to the port of destination such as container numbers, estimated time of arrival, vessel details and containers information.
+They may be written in different languages such as English, German, Italian and can appear in a variety of formats and layouts.
+Your role is to accurately extract specific entities from these Arrival Notices to support efficient processing and accurate record-keeping.
+<CONTEXT>
+
+<INSTRUCTIONS>
+- Populate fields as defined in the response schema.
+- Multiple Containers entries may exist, capture all instances under "containers".
+- Use the data field description to understand the context of the data.
+
+- bookingNumbers:
+    - Booking numbers are unique identifiers for shipments. They are often referred to as "Booking Number", "Booking No.", "Booking Ref.", "Booking Reference", "Booking ID", "SACO-Pos.", "Order Ref", "Unsere Referenz", or "Unsere Position"
+    - If there is a unique_id that starts with "S" followed by 6 or 8 digits, it is a shipmentID, not a bookingNumber.
+
+- destinationTerminal:
+    - Destination Terminal can also be referred to as "Destination Termina;", "Pickup Location", "Delivery Location", "Delivery Terminal", "Empfangsort", "Entladeort", or "Abladestelle".
+
+- mblNumbers:
+    - Commonly known as "Bill of Lading Number", "BILL OF LADING NO.", "BL Number", "BL No.", "B/L No.", "BL-Nr.", "B/L", "HBL No.", or "M-AWB Nummer".
+    - Bill of Lading Number is known as mblNumber. Not a shipmentID even if it starts with "S".
+    - mblNumber from Hapag-Lloyd always starts with HLC.... (e.g., "HLCUTS12303AWNT3) and named as SEA WAYBILL or "SWB-NR.
+
+- eta:
+    - Estimated Time of Arrival (ETA) is the expected date and time when the shipment will arrive at the destination port.
+    - It can be referred to as "ETA", "Estimated Arrival", "Voraussichtliche Ankunft", "Ankunftszeit", "Arrivo", "Due to arrive at Terminal"
+
+- vesselName:
+    - Vessel Name is the name of the ship carrying the cargo. It can be referred to as "Vessel", "Ship Name", "Schiff", "Schiffsname", "Nave", or "Vessel/Flight No.".
+
+- containers: Details of each container on the arrival notice. Make sure to extract each container information separately.
+    - containerNumber: Container Number consists of 4 capital letters followed by 7 digits (e.g., TEMU7972458, CAIU 7222892).
+    - sealNumber: Seal numbers are unique identifiers for shipping seals. They are usually mentioned as seal numbers in the document but they are definitely not container numbers.
+
+<INSTRUCTIONS>

src/prompts/library/bookingConfirmation/evergreen/placeholders.json

@@ -1,28 +1,28 @@
 {
   "type": "OBJECT",
   "properties": {
-    "cfsCutOff": {"type": "string", "nullable": true, "description": "he date by which an LCL (Less than Container Load) shipment needs to be checked in to a CFS (Container Freight Station) to meet its scheduled sailing"},
-    "bookingNumber": {"type": "string", "nullable": true},
-    "cyCutOff": {"type": "string", "nullable": true},
-    "gateInReference": {"type": "string", "nullable": true},
-    "gateInTerminal": {"type": "string", "nullable": true},
-    "mblNumber": {"type": "string", "nullable": true},
-    "pickUpReference": {"type": "string", "nullable": true},
-    "pickUpTerminal": {"type": "string", "nullable": true},
-    "siCutOff": {"type": "string", "nullable": true},
-    "vgmCutOff": {"type": "string", "nullable": true},
+    "cfsCutOff": {"type": "STRING", "nullable": true, "description": "the date by which an LCL (Less than Container Load) shipment needs to be checked in to a CFS (Container Freight Station) to meet its scheduled sailing"},
+    "bookingNumber": {"type": "STRING", "nullable": true},
+    "cyCutOff": {"type": "STRING", "nullable": true},
+    "gateInReference": {"type": "STRING", "nullable": true},
+    "gateInTerminal": {"type": "STRING", "nullable": true},
+    "mblNumber": {"type": "STRING", "nullable": true},
+    "pickUpReference": {"type": "STRING", "nullable": true},
+    "pickUpTerminal": {"type": "STRING", "nullable": true},
+    "siCutOff": {"type": "STRING", "nullable": true},
+    "vgmCutOff": {"type": "STRING", "nullable": true},
     "transportLegs": {
       "type": "ARRAY",
       "items": {
         "type": "OBJECT",
         "properties": {
-            "eta": {"type": "string", "nullable": true},
-            "etd": {"type": "string", "nullable": true},
-            "imoNumber": {"type": "string", "nullable": true},
-            "portOfDischarge": {"type": "string", "nullable": true},
-            "portOfLoading": {"type": "string", "nullable": true},
-            "vesselName": {"type": "string", "nullable": true},
-            "voyage": {"type": "string", "nullable": true}
+            "eta": {"type": "STRING", "nullable": true},
+            "etd": {"type": "STRING", "nullable": true},
+            "imoNumber": {"type": "STRING", "nullable": true},
+            "portOfDischarge": {"type": "STRING", "nullable": true},
+            "portOfLoading": {"type": "STRING", "nullable": true},
+            "vesselName": {"type": "STRING", "nullable": true},
+            "voyage": {"type": "STRING", "nullable": true}
           },
         "required": []
       }

src/prompts/library/bookingConfirmation/evergreen/prompt.txt

@@ -1,3 +1,4 @@
+your task is to extract the text value of the following entities and page numbers starting from 0 where the value was found in the document:
 ```json
 {
 "mblNumber": "Extract the value after the label 'BOOKING NO.'.",

src/prompts/library/bookingConfirmation/hapag-lloyd/placeholders.json

@@ -1,32 +1,32 @@
 {
   "type": "OBJECT",
   "properties": {
-    "cfsCutOff": {"type": "string", "nullable": true, "description": "he date by which an LCL (Less than Container Load) shipment needs to be checked in to a CFS (Container Freight Station) to meet its scheduled sailing"},
-    "bookingNumber": {"type": "string", "nullable": true},
-    "cyCutOff": {"type": "string", "nullable": true},
-    "gateInReference": {"type": "string", "nullable": true},
-    "gateInTerminal": {"type": "string", "nullable": true},
-    "mblNumber": {"type": "string", "nullable": true},
-    "pickUpReference": {"type": "string", "nullable": true},
-    "pickUpTerminal": {"type": "string", "nullable": true},
-    "siCutOff": {"type": "string", "nullable": true},
-    "vgmCutOff": {"type": "string", "nullable": true},
+    "cfsCutOff": {"type": "STRING", "nullable": true, "description": "the date by which an LCL (Less than Container Load) shipment needs to be checked in to a CFS (Container Freight Station) to meet its scheduled sailing"},
+    "bookingNumber": {"type": "STRING", "nullable": true},
+    "cyCutOff": {"type": "STRING", "nullable": true},
+    "gateInReference": {"type": "STRING", "nullable": true},
+    "gateInTerminal": {"type": "STRING", "nullable": true},
+    "mblNumber": {"type": "STRING", "nullable": true},
+    "pickUpReference": {"type": "STRING", "nullable": true},
+    "pickUpTerminal": {"type": "STRING", "nullable": true},
+    "siCutOff": {"type": "STRING", "nullable": true},
+    "vgmCutOff": {"type": "STRING", "nullable": true},
     "transportLegs": {
       "type": "ARRAY",
       "items": {
         "type": "OBJECT",
         "properties": {
-            "eta": {"type": "string", "nullable": true},
-            "etd": {"type": "string", "nullable": true},
-            "imoNumber": {"type": "string", "nullable": true},
-            "portOfDischarge": {"type": "string", "nullable": true},
-            "portOfLoading": {"type": "string", "nullable": true},
-            "vesselName": {"type": "string", "nullable": true},
-            "voyage": {"type": "string", "nullable": true}
+            "eta": {"type": "STRING", "nullable": true},
+            "etd": {"type": "STRING", "nullable": true},
+            "imoNumber": {"type": "STRING", "nullable": true},
+            "portOfDischarge": {"type": "STRING", "nullable": true},
+            "portOfLoading": {"type": "STRING", "nullable": true},
+            "vesselName": {"type": "STRING", "nullable": true},
+            "voyage": {"type": "STRING", "nullable": true}
           },
         "required": []
       }
     }
   },
   "required": []
-}
+}