ShipmentModel

מודל משלוחים מכיל קבוצה של משלוחים שצריך לבצע באמצעות קבוצה של כלי רכב, תוך צמצום העלות הכוללת, שהיא הסכום של:

  • עלות הניתוב של כלי הרכב (סכום העלות לזמן הכולל, העלות לזמן הנסיעה והעלות הקבועה לכל כלי הרכב).
  • קנסות על משלוחים שלא בוצעו.
  • עלות המשלוחים בכל העולם
ייצוג ב-JSON 
{
  "shipments": [
    {
      object (Shipment)
    }
  ],
  "vehicles": [
    {
      object (Vehicle)
    }
  ],
  "objectives": [
    {
      object (Objective)
    }
  ],
  "globalStartTime": string,
  "globalEndTime": string,
  "globalDurationCostPerHour": number,
  "durationDistanceMatrices": [
    {
      object (DurationDistanceMatrix)
    }
  ],
  "durationDistanceMatrixSrcTags": [
    string
  ],
  "durationDistanceMatrixDstTags": [
    string
  ],
  "transitionAttributes": [
    {
      object (TransitionAttributes)
    }
  ],
  "shipmentTypeIncompatibilities": [
    {
      object (ShipmentTypeIncompatibility)
    }
  ],
  "shipmentTypeRequirements": [
    {
      object (ShipmentTypeRequirement)
    }
  ],
  "precedenceRules": [
    {
      object (PrecedenceRule)
    }
  ],
  "maxActiveVehicles": integer
}
שדות
shipments[]

object (Shipment)

קבוצת משלוחים שצריך לבצע במודל.
vehicles[]

object (Vehicle)

קבוצת כלי הרכב שאפשר להשתמש בהם כדי לבצע את הביקורים.
objectives[]

object (Objective)

קבוצת היעדים של המודל הזה, שאותם נהפוך לעלויות. אם הוא לא ריק, מודל הקלט צריך להיות ללא עלות. כדי לקבל את הבקשה ששונתה, צריך להשתמש ב-solvingMode = TRANSFORM_AND_RETURN_REQUEST. חשוב לדעת שבמקרה כזה הבקשה לא תטופל. לעיון במסמכי התיעוד המתאימים.

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.
globalStartTime

string (Timestamp format)

שעת ההתחלה ושעת הסיום של המודל: שעות מחוץ לטווח הזה לא נחשבות חוקיות.

טווח הזמן של המודל חייב להיות פחות משנה, כלומר ההפרש בין globalEndTime ל-globalStartTime חייב להיות פחות מ-31,536,000 שניות.

כשמשתמשים בשדות cost_per_*hour, כדאי להגדיר חלון זמן קצר יותר כדי לשפר את הביצועים (למשל, אם יוצרים מודל ליום אחד, צריך להגדיר את מגבלות הזמן הגלובליות לאותו יום). אם לא מגדירים את השדה, ערך ברירת המחדל הוא 00:00:00 UTC, ‏ 1 בינואר 1970 (כלומר, שניות: 0, ננו-שניות: 0).

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
globalEndTime

string (Timestamp format)

אם לא מגדירים את השדה, ערך ברירת המחדל הוא 00:00:00 UTC, ‏ 1 בינואר 1971 (כלומר, שניות: 31536000, ננו-שניות: 0).

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
globalDurationCostPerHour

number

"משך הזמן הגלובלי" של התוכנית הכוללת הוא ההפרש בין שעת ההתחלה האפקטיבית המוקדמת ביותר לבין שעת הסיום האפקטיבית המאוחרת ביותר של כל הרכבים. המשתמשים יכולים להקצות עלות לשעה לכמות הזו כדי לנסות לבצע אופטימיזציה להשלמת המשימה המוקדמת ביותר, למשל. העלות הזו צריכה להיות באותה יחידה כמו Shipment.penalty_cost.
durationDistanceMatrices[]

object (DurationDistanceMatrix)

מציין את מטריצות משך הזמן ומטריצת המרחקים שבהן נעשה שימוש במודל. אם השדה הזה ריק, המערכת תשתמש במפות Google או במרחקים גיאודזיים, בהתאם לערך בשדה useGeodesicDistances. אם הוא לא ריק, הערך של useGeodesicDistances לא יכול להיות True, והערכים של durationDistanceMatrixSrcTags ו-durationDistanceMatrixDstTags לא יכולים להיות ריקים.

דוגמאות לשימוש:

  • יש שני מיקומים: מיקום א' ומיקום ב'.
  • רכב אחד שמתחיל את המסלול ב-locA ומסיים אותו ב-locA.
  • בקשה אחת לאיסוף במיקום ב'.
model {
  vehicles { startTags: "locA"  endTags: "locA" }
  shipments { pickups { tags: "locB" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixDstTags: "locA"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrices {
    rows {  # from: locA
      durations { seconds: 0 }   meters: 0    # to: locA
      durations { seconds: 100 } meters: 1000 # to: locB
    }
    rows {  # from: locB
      durations { seconds: 102 } meters: 990 # to: locA
      durations { seconds: 0 }   meters: 0   # to: locB
    }
  }
}
  • יש שלושה מיקומים: locA, ‏ locB ו-locC.
  • רכב אחד שמתחיל את המסלול ב-locA ומסיים אותו ב-locB, באמצעות המטריצה "fast".
  • רכב אחד שמתחיל את המסלול ב-locB ומסיים אותו ב-locB, באמצעות המטריצה "slow".
  • רכב אחד שמתחיל את המסלול ב-locB ומסיים אותו ב-locB, באמצעות המטריצה "fast".
  • בקשה אחת לאיסוף במיקום C.
model {
  vehicles { startTags: "locA" endTags: "locB" startTags: "fast" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "slow" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "fast" }
  shipments { pickups { tags: "locC" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixSrcTags: "locC"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrixDstTags: "locC"
  durationDistanceMatrices {
    vehicleStartTag: "fast"
    rows {  # from: locA
      durations { seconds: 1000 } meters: 2000 # to: locB
      durations { seconds: 600 }  meters: 1000 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }   meters: 0    # to: locB
      durations { seconds: 700 } meters: 1200 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 702 } meters: 1190 # to: locB
      durations { seconds: 0 }   meters: 0    # to: locC
    }
  }
  durationDistanceMatrices {
    vehicleStartTag: "slow"
    rows {  # from: locA
      durations { seconds: 1800 } meters: 2001 # to: locB
      durations { seconds: 900 }  meters: 1002 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }    meters: 0    # to: locB
      durations { seconds: 1000 } meters: 1202 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 1001 } meters: 1195 # to: locB
      durations { seconds: 0 }    meters: 0    # to: locC
    }
  }
}
durationDistanceMatrixSrcTags[]

string

תגים שמגדירים את המקורות של מטריצות משך הזמן והמרחק. durationDistanceMatrices(i).rows(j) מגדיר את משכי הזמן והמרחקים מביקורים עם התג durationDistanceMatrixSrcTags(j) לביקורים אחרים במטריצה i.

התגים תואמים ל-VisitRequest.tags או ל-Vehicle.start_tags. VisitRequest או Vehicle נתונים חייבים להתאים בדיוק לתג אחד בשדה הזה. שימו לב שתגי המקור, היעד והמטריצה של Vehicle עשויים להיות זהים. באופן דומה, תגי המקור והיעד של VisitRequest עשויים להיות זהים. כל התגים צריכים להיות שונים ולא יכולים להיות מחרוזות ריקות. אם השדה הזה לא ריק, גם השדה durationDistanceMatrices לא יכול להיות ריק.
durationDistanceMatrixDstTags[]

string

תגים שמגדירים את היעדים של מטריצות משך הזמן ומטריצות המרחקים; durationDistanceMatrices(i).rows(j).durations(k) (בהתאמה, durationDistanceMatrices(i).rows(j).meters(k)) מגדיר את משך הנסיעה (או המרחק) מביקורים עם התג durationDistanceMatrixSrcTags(j) לביקורים עם התג durationDistanceMatrixDstTags(k) במטריצה i.

התגים תואמים ל-VisitRequest.tags או ל-Vehicle.start_tags. VisitRequest או Vehicle נתונים חייבים להתאים בדיוק לתג אחד בשדה הזה. שימו לב שתגי המקור, היעד והמטריצה של Vehicle עשויים להיות זהים. באופן דומה, תגי המקור והיעד של VisitRequest עשויים להיות זהים. כל התגים צריכים להיות שונים ולא יכולים להיות מחרוזות ריקות. אם השדה הזה לא ריק, גם השדה durationDistanceMatrices לא יכול להיות ריק.
transitionAttributes[]

object (TransitionAttributes)

מאפייני המעבר נוספו למודל.
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

קבוצות של סוגי משלוחים (shipment_types) שלא תואמים (ראו ShipmentTypeIncompatibility).
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

קבוצות של דרישות shipmentType (ראו ShipmentTypeRequirement).
precedenceRules[]

object (PrecedenceRule)

קבוצה של כללי קדימות שצריך לאכוף במודל.

חשוב: השימוש בכללי קדימויות מגביל את גודל הבעיה שאפשר לבצע לה אופטימיזציה. יכול להיות שנדחה בקשות שכוללות כללי קדימות עם הרבה משלוחים.
maxActiveVehicles

integer

מגביל את המספר המקסימלי של כלי רכב פעילים. רכב נחשב פעיל אם המסלול שלו כולל לפחות משלוח אחד. אפשר להשתמש בזה כדי להגביל את מספר המסלולים במקרים שבהם יש פחות נהגים מכלי רכב, וצי הרכבים הוא הטרוגני. לאחר מכן, האופטימיזציה תבחר את קבוצת המשנה הטובה ביותר של כלי הרכב לשימוש. הערך חייב להיות חיובי.

משלוח

משלוח של פריט אחד, מנקודת איסוף אחת לנקודת מסירה אחת. כדי שהמשלוח ייחשב כמבוצע, רכב ייחודי צריך לבקר באחד ממיקומי האיסוף שלו (ולהקטין את הקיבולת הפנויה שלו בהתאם), ואז לבקר באחד ממיקומי המסירה שלו בשלב מאוחר יותר (ולכן להגדיל מחדש את הקיבולת הפנויה שלו בהתאם).

ייצוג ב-JSON 
{
  "displayName": string,
  "pickups": [
    {
      object (VisitRequest)
    }
  ],
  "deliveries": [
    {
      object (VisitRequest)
    }
  ],
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "allowedVehicleIndices": [
    integer
  ],
  "costsPerVehicle": [
    number
  ],
  "costsPerVehicleIndices": [
    integer
  ],
  "pickupToDeliveryAbsoluteDetourLimit": string,
  "pickupToDeliveryTimeLimit": string,
  "shipmentType": string,
  "label": string,
  "ignore": boolean,
  "penaltyCost": number,
  "pickupToDeliveryRelativeDetourLimit": number
}
שדות
displayName

string

השם המוצג של המשלוח, שמוגדר על ידי המשתמש. הוא יכול להכיל עד 63 תווים, כולל תווים בקידוד UTF-8.
pickups[]

object (VisitRequest)

קבוצה של אפשרויות איסוף שמשויכות למשלוח. אם לא מציינים את המיקום, הרכב צריך להגיע רק למיקום שתואם למשלוחים.
deliveries[]

object (VisitRequest)

קבוצה של אפשרויות משלוח שמשויכות למשלוח. אם לא מציינים את המיקום, הרכב צריך להגיע רק למיקום שתואם לאיסופים.
loadDemands

map (key: string, value: object (Load))

דרישות העומס של המשלוח (לדוגמה: משקל, נפח, מספר משטחים וכו'). המפתחות במפה צריכים להיות מזהים שמתארים את סוג העומס המתאים, ורצוי לכלול גם את היחידות. לדוגמה: "weight_kg",‏ "volume_gallons",‏ "pallet_count" וכו'. אם מפתח מסוים לא מופיע במפה, העומס התואם נחשב כ-null.
allowedVehicleIndices[]

integer

קבוצת כלי הרכב שיכולים לבצע את המשלוח הזה. אם השדה ריק, כל כלי הרכב יכולים לבצע את המשימה. הרכבים מיוצגים על ידי האינדקס שלהם ברשימת vehicles של ShipmentModel.
costsPerVehicle[]

number

מציין את העלות שנוצרת כשהמשלוח הזה נמסר על ידי כל רכב. אם מציינים את המאפיין, הוא חייב לכלול אחד מהשניים:

  • אותו מספר של רכיבים כמו ב-costsPerVehicleIndices. costsPerVehicle[i] תואם לרכב costsPerVehicleIndices[i] של המודל.
  • מספר הרכיבים צריך להיות זהה למספר כלי הרכב במודל. הרכיב ה-i תואם לרכב מספר i של המודל.

העלויות האלה צריכות להיות באותה יחידה כמו penaltyCost, והן לא יכולות להיות שליליות. אם אין עלויות כאלה, משאירים את השדה הזה ריק.
costsPerVehicleIndices[]

integer

אינדקסים של כלי הרכב שעליהם חל costsPerVehicle. אם השדה לא ריק, הוא חייב להכיל את אותו מספר רכיבים כמו costsPerVehicle. אי אפשר לציין אינדקס רכב יותר מפעם אחת. אם רכב מסוים לא נכלל ב-costsPerVehicleIndices, העלות שלו היא אפס.
pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

מציינת את זמן העיקוף המוחלט המקסימלי בהשוואה למסלול הקצר ביותר מנקודת האיסוף ועד לנקודת המסירה. אם מציינים את המאפיין הזה, הערך שלו חייב להיות חיובי, והמשלוח חייב לכלול לפחות איסוף אחד ומסירה אחת.

לדוגמה, נניח ש-t הוא הזמן הקצר ביותר שלוקח להגיע מהחלופה שנבחרה לאיסוף ישירות לחלופה שנבחרה למסירה. ואז ההגדרה pickupToDeliveryAbsoluteDetourLimit אוכפת:

startTime(delivery) - startTime(pickup) <=
t + pickupToDeliveryAbsoluteDetourLimit

אם מגדירים גם מגבלות יחסיות וגם מגבלות מוחלטות לאותו משלוח, המערכת משתמשת במגבלה המחמירה יותר לכל זוג אפשרי של איסוף/מסירה. נכון לאוקטובר 2017, יש תמיכה בנסיעות עקיפות רק כשמשך הנסיעה לא תלוי בכלי הרכב.
pickupToDeliveryTimeLimit

string (Duration format)

מציין את משך הזמן המקסימלי מתחילת האיסוף ועד לתחילת המסירה של המשלוח. אם מציינים את המאפיין הזה, הערך שלו חייב להיות חיובי, והמשלוח חייב לכלול לפחות איסוף אחד ומסירה אחת. הזמן הזה לא תלוי באפשרויות שנבחרו לאיסוף ולמסירה, וגם לא במהירות הרכב. אפשר לציין את זה לצד אילוצי סטייה מקסימלית: הפתרון יכבד את שני המפרטים.
shipmentType

string

מחרוזת לא ריקה שמציינת את סוג המשלוח. אפשר להשתמש בתכונה הזו כדי להגדיר חוסר תאימות או דרישות בין shipment_types (ראו shipmentTypeIncompatibilities ו-shipmentTypeRequirements ב-ShipmentModel).

השדה הזה שונה מהשדה visitTypes, שמצוין לביקור בודד: כל האיסופים/המסירות ששייכים לאותו משלוח חולקים את אותו shipmentType.
label

string

מציין תווית למשלוח הזה. התווית הזו מדווחת בתגובה ב-shipmentLabel של ה-ShipmentRoute.Visit המתאים.
ignore

boolean

אם הערך הוא True, המערכת מדלגת על המשלוח הזה, אבל לא מחילה penaltyCost.

התעלמות ממשלוח גורמת לשגיאת אימות כשיש shipmentTypeRequirements במודל.

מותר להתעלם ממשלוח שמבוצע ב-injectedFirstSolutionRoutes או ב-injectedSolutionConstraint. פותר הבעיות מסיר את ביקורי האיסוף או המסירה הקשורים מהמסלול שמבוצע. precedenceRules שמתייחסים למשלוחים שהמערכת מתעלמת מהם.
penaltyCost

number

אם המשלוח לא יושלם, הקנס הזה יתווסף לעלות הכוללת של המסלולים. משלוח נחשב כהושלם אם מבקרים באחת מהחלופות לאיסוף ולמסירה שלו. אפשר לבטא את העלות באותה יחידה שבה משתמשים בכל שאר השדות שקשורים לעלות במודל, והיא חייבת להיות חיובית.

חשוב: אם לא מציינים את הקנס, הוא נחשב לאינסופי, כלומר חובה להשלים את המשלוח.
pickupToDeliveryRelativeDetourLimit

number

מציין את משך הזמן המקסימלי של עיקוף יחסי בהשוואה למסלול הקצר ביותר מנקודת האיסוף ועד לנקודת המסירה. אם מציינים את המאפיין הזה, הערך שלו חייב להיות חיובי, והמשלוח חייב לכלול לפחות איסוף אחד ומסירה אחת.

לדוגמה, נניח ש-t הוא הזמן הקצר ביותר שלוקח להגיע מהאפשרות שנבחרה לאיסוף ישירות לאפשרות שנבחרה למסירה. ואז ההגדרה pickupToDeliveryRelativeDetourLimit אוכפת:

startTime(delivery) - startTime(pickup) <=
std::ceil(t * (1.0 + pickupToDeliveryRelativeDetourLimit))

אם מגדירים גם מגבלות יחסיות וגם מגבלות מוחלטות לאותו משלוח, המערכת משתמשת במגבלה המחמירה יותר לכל זוג אפשרי של איסוף/מסירה. נכון לאוקטובר 2017, יש תמיכה בנסיעות עקיפות רק כשמשך הנסיעה לא תלוי בכלי הרכב.

VisitRequest

בקשה לביקור שאפשר לבצע באמצעות רכב: יש לה מיקום גיאוגרפי (או שניים, ראו בהמשך), שעות פתיחה וסגירה שמיוצגות על ידי חלונות זמן, ומשך זמן שירות (הזמן שהרכב מבלה מרגע שהגיע לאסוף או לפרוק סחורה).

ייצוג ב-JSON 
{
  "arrivalLocation": {
    object (LatLng)
  },
  "arrivalWaypoint": {
    object (Waypoint)
  },
  "departureLocation": {
    object (LatLng)
  },
  "departureWaypoint": {
    object (Waypoint)
  },
  "tags": [
    string
  ],
  "timeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "duration": string,
  "cost": number,
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "visitTypes": [
    string
  ],
  "label": string,
  "avoidUTurns": boolean
}
שדות
arrivalLocation

object (LatLng)

המיקום הגיאוגרפי שאליו הרכב מגיע כשמבצעים את הVisitRequest הזה. אם למודל המשלוח יש מטריצות של משך זמן ומרחק, אסור לציין את arrivalLocation.
arrivalWaypoint

object (Waypoint)

נקודת הדרך שאליה הרכב מגיע כשמבצעים את ה-VisitRequest הזה. אם למודל המשלוח יש מטריצות של משך זמן ומרחק, אסור לציין את arrivalWaypoint.
departureLocation

object (LatLng)

המיקום הגיאוגרפי שממנו הרכב יוצא אחרי השלמת VisitRequest. אפשר להשמיט את השדה הזה אם הוא זהה לשדה arrivalLocation. אם למודל המשלוח יש מטריצות של משך זמן ומרחק, אסור לציין את departureLocation.
departureWaypoint

object (Waypoint)

נקודת הציון שבה הרכב יוצא אחרי השלמת VisitRequest. אפשר להשמיט את השדה הזה אם הוא זהה לשדה arrivalWaypoint. אם למודל המשלוח יש מטריצות של משך זמן ומרחק, אסור לציין את departureWaypoint.
tags[]

string

מציין תגים שמצורפים לבקשת הביקור. אסור להשתמש במחרוזות ריקות או כפולות.
timeWindows[]

object (TimeWindow)

חלונות זמן שמגבילים את זמן ההגעה לביקור. שימו לב שכלי רכב יכול לצאת מחוץ לחלון זמן ההגעה, כלומר זמן ההגעה + משך הזמן לא צריכים להיות בתוך חלון זמן. אם הרכב יגיע לפני TimeWindow.start_time, יכול להיות שתצטרכו לחכות.

אם לא מצוין TimeWindow, הרכב יכול לבצע את הביקור בכל שלב.

חלונות הזמן חייבים להיות נפרדים, כלומר אסור שחלון זמן אחד יחפוף לחלון זמן אחר או יהיה סמוך אליו, והם חייבים להיות בסדר עולה.

אפשר להגדיר את costPerHourAfterSoftEndTime ו-softEndTime רק אם יש חלון זמן אחד.
duration

string (Duration format)

משך הביקור, כלומר הזמן שהרכב נמצא במקום בין ההגעה לעזיבה (צריך להוסיף את זה לזמן ההמתנה האפשרי, ראו timeWindows).
cost

number

עלות הטיפול בבקשת הביקור הזו במסלול של רכב. אפשר להשתמש במאפיין הזה כדי לשלם עלויות שונות על כל אפשרות חלופית לאיסוף או למסירה של משלוח. העלות הזו צריכה להיות באותה יחידה כמו Shipment.penalty_cost ולא יכולה להיות שלילית.
loadDemands

map (key: string, value: object (Load))

העומס שנוצר בעקבות בקשת הביקור הזו. השדה הזה זהה לשדה Shipment.load_demands, אבל הוא חל רק על VisitRequest במקום על כל Shipment. הדרישות שמפורטות כאן מתווספות לדרישות שמפורטות ב-Shipment.load_demands.
visitTypes[]

string

מציין את סוגי הביקורים. אפשר להשתמש בזה כדי להקצות זמן נוסף שנדרש לרכב כדי להשלים את הביקור (ראו Vehicle.extra_visit_duration_for_visit_type).

כל סוג יכול להופיע רק פעם אחת.
label

string

מציינת תווית ל-VisitRequest הזה. התווית הזו מדווחת בתגובה בתור visitLabel ב-ShipmentRoute.Visit התואם.
avoidUTurns

boolean

מציינת אם צריך להימנע מפניות פרסה במסלולי נסיעה במיקום הזה. הימנעות מפניות פרסה היא כמיטב יכולתנו, ואין הבטחה להימנעות מוחלטת. זו תכונה ניסיונית וההתנהגות שלה עשויה להשתנות.

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request.

LatLng

אובייקט שמייצג זוג של קו רוחב וקו אורך. המיקום מיוצג על ידי זוג ערכים מסוג double שמייצגים את המעלות של קו הרוחב וקו האורך. אם לא צוין אחרת, האובייקט הזה חייב לעמוד ב תקן WGS84. הערכים צריכים להיות בטווחים מנורמלים.

ייצוג ב-JSON 
{
  "latitude": number,
  "longitude": number
}
שדות
latitude

number

קו הרוחב במעלות. הוא חייב להיות בטווח [‎-90.0, +90.0].
longitude

number

קו האורך במעלות. הוא חייב להיות בטווח [‎-180.0, +180.0].

נקודת ציון

מכיל נקודת דרך. נקודות ציון מסמנות את מיקומי ההגעה והיציאה של VisitRequests, ואת מיקומי ההתחלה והסיום של כלי הרכב.

ייצוג ב-JSON 
{
  "sideOfRoad": boolean,
  "vehicleStopover": boolean,

  // The following is a list of mutually exclusive fields. At most one of the
  // fields will be set in a response:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of mutually exclusive fields.
}
שדות
sideOfRoad

boolean

אופציונלי. מציין שהמיקום של נקודת הדרך הזו נועד להעדפה שהרכב יעצור בצד מסוים של הכביש. כשמגדירים את הערך הזה, המסלול יעבור דרך המיקום כך שהרכב יוכל לעצור בצד הכביש שהמיקום נוטה אליו ממרכז הכביש. האפשרות הזו לא פועלת במצב הנסיעה WALKING.
vehicleStopover

boolean

מציינת שציון הדרך מיועד לעצירת כלי רכב, במטרה לאסוף או להוריד. האפשרות הזו פועלת רק במצב הנסיעה 'נהיגה', וכאשר הערך של locationType הוא location.

ניסיוני: ההתנהגות או הקיום של השדה הזה עשויים להשתנות בעתיד.
דרכים שונות לייצג מיקום. ברשימה הבאה מופיעים שדות שמוציאים זה את זה. בתשובה יוגדר לכל היותר אחד מהשדות הבאים:
location

object (Location)

נקודה שצוינה באמצעות קואורדינטות גיאוגרפיות, כולל כיוון אופציונלי.
placeId

string

מזהה המקום של נקודת העניין שמשויך לציון הדרך.

כשמשתמשים במזהה מקום כדי לציין את מיקום ההגעה או היציאה של VisitRequest, צריך להשתמש במזהה מקום ספציפי מספיק כדי לקבוע מיקום LatLng לניווט למקום. לדוגמה, מזהה מקום שמייצג בניין מתאים, אבל לא מומלץ להשתמש במזהה מקום שמייצג כביש.
סוף השדות שמוציאים זה את זה.

מיקום

מכיל מיקום (נקודה גיאוגרפית וכיוון אופציונלי).

ייצוג ב-JSON 
{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}
שדות
latLng

object (LatLng)

הקואורדינטות הגיאוגרפיות של נקודת הדרך.
heading

integer

כיוון המצפן שמשויך לכיוון זרימת התנועה. הערך הזה משמש כדי לציין את צד הכביש שבו צריך להשתמש לאיסוף ולהורדה. ערכי הכיוון יכולים להיות בין 0 ל-360, כאשר 0 מציין כיוון צפונה, 90 מציין כיוון מזרחה וכו'.

TimeWindow

חלונות זמן מגבילים את הזמן של אירוע, כמו זמן ההגעה לביקור, או שעת ההתחלה והסיום של רכב.

גבולות קשיחים של חלון הזמן, startTime ו-endTime, אוכפים את השעה המוקדמת ביותר והמאוחרת ביותר של האירוע, כך ש-startTime <= event_time <= endTime. הגבול התחתון של חלון הזמן הגמיש, softStartTime, מבטא העדפה שהאירוע יתרחש ב-softStartTime או אחריו, על ידי צבירת עלות פרופורציונלית למשך הזמן שבו האירוע מתרחש לפני softStartTime. הגבול העליון של חלון הזמן הגמיש, softEndTime, מבטא העדפה שהאירוע יתרחש ב-softEndTime או לפני כן, על ידי צבירת עלות פרופורציונלית למשך הזמן שחלף אחרי softEndTime עד שהאירוע התרחש. ‫startTime,‏ endTime,‏ softStartTime ו-softEndTime צריכים להיות בטווח של מגבלות הזמן הגלובליות (ראו ShipmentModel.global_start_time ו-ShipmentModel.global_end_time) ולעמוד בתנאים הבאים:

  0 <= `startTime` <= `endTime` and
  0 <= `startTime` <= `softStartTime` and
  0 <= `softEndTime` <= `endTime`.
ייצוג ב-JSON 
{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}
שדות
startTime

string (Timestamp format)

שעת ההתחלה של חלון הזמן הקשיח. אם לא מציינים ערך, הוא מוגדר כ-ShipmentModel.global_start_time.

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
endTime

string (Timestamp format)

שעת הסיום של חלון הזמן הקשיח. אם לא מציינים ערך, הוא מוגדר כ-ShipmentModel.global_end_time.

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
softStartTime

string (Timestamp format)

שעת ההתחלה הגמישה של חלון הזמן.

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
softEndTime

string (Timestamp format)

שעת הסיום הגמישה של חלון הזמן.

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
costPerHourBeforeSoftStartTime

number

עלות לשעה שמתווספת לעלויות אחרות במודל אם האירוע מתרחש לפני softStartTime, ומחושבת כך:

   max(0, softStartTime - t.seconds)
                          * costPerHourBeforeSoftStartTime / 3600,
t being the time of the event.

העלות הזו חייבת להיות חיובית, ואפשר להגדיר את השדה רק אם הוגדר softStartTime.
costPerHourAfterSoftEndTime

number

עלות לשעה שמתווספת לעלויות אחרות במודל אם האירוע מתרחש אחרי softEndTime, ומחושבת כך:

   max(0, t.seconds - softEndTime.seconds)
                    * costPerHourAfterSoftEndTime / 3600,
t being the time of the event.

העלות הזו חייבת להיות חיובית, ואפשר להגדיר את השדה רק אם הוגדר softEndTime.

כלי רכב

מודל של רכב בבעיית משלוח. פתרון בעיה במשלוח יבנה מסלול שמתחיל ב-startLocation ומסתיים ב-endLocation לרכב הזה. מסלול הוא רצף של ביקורים (ראו ShipmentRoute).

ייצוג ב-JSON 
{
  "displayName": string,
  "travelMode": enum (TravelMode),
  "routeModifiers": {
    object (RouteModifiers)
  },
  "startLocation": {
    object (LatLng)
  },
  "startWaypoint": {
    object (Waypoint)
  },
  "endLocation": {
    object (LatLng)
  },
  "endWaypoint": {
    object (Waypoint)
  },
  "startTags": [
    string
  ],
  "endTags": [
    string
  ],
  "startTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "endTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "unloadingPolicy": enum (UnloadingPolicy),
  "loadLimits": {
    string: {
      object (LoadLimit)
    },
    ...
  },
  "costPerHour": number,
  "costPerTraveledHour": number,
  "costPerKilometer": number,
  "fixedCost": number,
  "usedIfRouteIsEmpty": boolean,
  "routeDurationLimit": {
    object (DurationLimit)
  },
  "travelDurationLimit": {
    object (DurationLimit)
  },
  "routeDistanceLimit": {
    object (DistanceLimit)
  },
  "extraVisitDurationForVisitType": {
    string: string,
    ...
  },
  "breakRule": {
    object (BreakRule)
  },
  "label": string,
  "ignore": boolean,
  "travelDurationMultiple": number
}
שדות
displayName

string

השם שהמשתמש הגדיר לתצוגה של הרכב. הוא יכול להכיל עד 63 תווים, כולל תווים בקידוד UTF-8.
travelMode

enum (TravelMode)

אופן הנסיעה, שמשפיע על הכבישים שבהם הרכב יכול לנסוע ועל המהירות שלו. מידע נוסף מופיע ב-travelDurationMultiple.
routeModifiers

object (RouteModifiers)

קבוצת תנאים שמשפיעים על אופן חישוב המסלולים של הרכב הנתון.
startLocation

object (LatLng)

המיקום הגיאוגרפי שבו הרכב מתחיל את הנסיעה לפני שהוא אוסף משלוחים. אם לא מציינים מיקום, הרכב מתחיל באיסוף הראשון שלו. אם למודל המשלוח יש מטריצות של משך זמן ומטריצת מרחקים, אסור לציין את startLocation.
startWaypoint

object (Waypoint)

נקודת ציון שמייצגת מיקום גיאוגרפי שבו הרכב מתחיל לפני איסוף המשלוחים. אם לא מציינים את startWaypoint או את startLocation, הרכב מתחיל באיסוף הראשון שלו. אם למודל המשלוח יש מטריצות של משך זמן ומטריצת מרחקים, אסור לציין את startWaypoint.
endLocation

object (LatLng)

המיקום הגיאוגרפי שבו הרכב מסיים את הנסיעה אחרי שהשלים את הVisitRequest האחרון שלו. אם לא מציינים את הערך, ה-ShipmentRoute של הרכב מסתיים מיד אחרי השלמת ה-VisitRequest האחרון. אם למודל המשלוח יש מטריצות של משך זמן ומטריצת מרחקים, אסור לציין את endLocation.
endWaypoint

object (Waypoint)

נקודת ציון שמייצגת מיקום גיאוגרפי שבו הרכב מסיים את הנסיעה אחרי שהשלים את ה-VisitRequest האחרון שלו. אם לא צוינו endWaypoint וגם לא endLocation, ה-ShipmentRoute של הרכב מסתיים מיד כשהוא משלים את ה-VisitRequest האחרון שלו. אם למודל המשלוח יש מטריצות של משך זמן ומטריצת מרחקים, אסור לציין את endWaypoint.
startTags[]

string

מציין תגים שמצורפים לתחילת המסלול של הרכב.

אסור להשתמש במחרוזות ריקות או כפולות.
endTags[]

string

מציין תגים שמצורפים לסוף המסלול של הרכב.

אסור להשתמש במחרוזות ריקות או כפולות.
startTimeWindows[]

object (TimeWindow)

חלונות זמן שבהם הרכב יכול לצאת ממיקום ההתחלה שלו. הם חייבים להיות בטווח הזמן הגלובלי (ראו שדות ShipmentModel.global_*). אם לא צוין אחרת, אין מגבלה מלבד מגבלות הזמן הגלובליות האלה.

חלונות זמן ששייכים לאותו שדה חוזר חייבים להיות נפרדים, כלומר אסור שחלון זמן כלשהו יחפוף לחלון זמן אחר או יהיה סמוך אליו, והם חייבים להיות בסדר כרונולוגי.

אפשר להגדיר את costPerHourAfterSoftEndTime ו-softEndTime רק אם יש חלון זמן אחד.
endTimeWindows[]

object (TimeWindow)

חלונות זמן שבהם הרכב יכול להגיע למיקום הסופי שלו. הם חייבים להיות בטווח הזמן הגלובלי (ראו שדות ShipmentModel.global_*). אם לא צוין אחרת, אין מגבלה מלבד מגבלות הזמן הגלובליות האלה.

חלונות זמן ששייכים לאותו שדה חוזר חייבים להיות נפרדים, כלומר אסור שחלון זמן כלשהו יחפוף לחלון זמן אחר או יהיה סמוך אליו, והם חייבים להיות בסדר כרונולוגי.

אפשר להגדיר את costPerHourAfterSoftEndTime ו-softEndTime רק אם יש חלון זמן אחד.
unloadingPolicy

enum (UnloadingPolicy)

מדיניות הפריקה שנאכפת ברכב.
loadLimits

map (key: string, value: object (LoadLimit))

קיבולת הרכב (למשל: משקל, נפח, מספר משטחים). המפתחות במפה הם המזהים של סוג העומס, בהתאם למפתחות של השדה Shipment.load_demands. אם מפתח מסוים לא מופיע במפה הזו, הקיבולת המתאימה נחשבת לבלתי מוגבלת.
costPerHour

number

עלויות הרכב: כל העלויות מצטברות וצריכות להיות באותה יחידה כמו Shipment.penalty_cost.

העלות לשעה של מסלול הרכב. העלות הזו חלה על משך הזמן הכולל של המסלול, וכוללת את זמן הנסיעה, זמן ההמתנה וזמן הביקור. שימוש ב-costPerHour במקום ב-costPerTraveledHour בלבד עלול לגרום לזמן אחזור נוסף.
costPerTraveledHour

number

העלות לשעת נסיעה במסלול של הרכב. העלות הזו חלה רק על זמן הנסיעה במסלול (כלומר, הזמן שדווח בשדה ShipmentRoute.transitions), ולא כוללת את זמן ההמתנה ואת זמן הביקור.
costPerKilometer

number

העלות לקילומטר במסלול של הרכב. העלות הזו חלה על המרחק שדווח ב-ShipmentRoute.transitions, ולא על מרחק שנסעו בו באופן משתמע מה-arrivalLocation אל ה-departureLocation של VisitRequest יחיד.
fixedCost

number

עלות קבועה שחלה אם משתמשים ברכב הזה לטיפול במשלוח.
usedIfRouteIsEmpty

boolean

השדה הזה רלוונטי רק לכלי רכב שהמסלול שלהם לא כולל משלוחים. הוא מציין אם הרכב נחשב כמשומש או לא במקרה הזה.

אם הערך הוא true, הרכב עובר ממיקום ההתחלה למיקום הסיום גם אם הוא לא מבצע משלוחים, ועלויות הזמן והמרחק שנובעות מהנסיעה ממיקום ההתחלה למיקום הסיום נלקחות בחשבון.

אחרת, הוא לא נוסע ממיקום ההתחלה למיקום הסיום, ולא מתוזמנים לרכב הזה breakRule או עיכוב (מ-TransitionAttributes). במקרה כזה, השדה ShipmentRoute של הרכב לא מכיל מידע מלבד האינדקס והתווית של הרכב.
routeDurationLimit

object (DurationLimit)

מגבלה שחלה על משך הזמן הכולל של מסלול הרכב. בOptimizeToursResponse נתון, משך המסלול של רכב הוא ההפרש בין vehicleEndTime ל-vehicleStartTime.
travelDurationLimit

object (DurationLimit)

מגבלה על משך הנסיעה במסלול של הרכב. בOptimizeToursResponse נתון, משך הנסיעה במסלול הוא הסכום של כל הtransitions.travel_duration שלו.
routeDistanceLimit

object (DistanceLimit)

מגבלה שחלה על המרחק הכולל של מסלול הרכב. בOptimizeToursResponse נתון, מרחק המסלול הוא הסכום של כל הtransitions.travel_distance_meters שלו.
extraVisitDurationForVisitType

map (key: string, value: string (Duration format))

מציין מיפוי ממחרוזות של visitTypes למשכי זמן. משך הזמן הוא הזמן שצריך להוסיף ל-VisitRequest.duration בביקורים עם ה-visitTypes שצוין. משך הביקור הנוסף הזה מוסיף עלות אם צוין costPerHour. מפתחות (למשל visitTypes) לא יכולים להיות מחרוזות ריקות.

אם לבקשת ביקור יש כמה סוגים, משך זמן יתווסף לכל סוג במפה.
breakRule

object (BreakRule)

תיאור של לוח הזמנים של ההפסקות שצריך לאכוף ברכב הזה. אם השדה ריק, לא יתוזמנו הפסקות לרכב הזה.
label

string

מציין תווית לרכב הזה. התווית הזו מדווחת בתגובה בתור vehicleLabel של ShipmentRoute התואם.
ignore

boolean

אם הערך הוא True, הערך של usedIfRouteIsEmpty חייב להיות False, ולא ייעשה שימוש בכלי הרכב הזה.

אם משלוח מתבצע על ידי רכב שמתעלמים ממנו ב-injectedFirstSolutionRoutes, המערכת מדלגת עליו בפתרון הראשון אבל אפשר לבצע אותו בתגובה.

אם משלוח מתבצע על ידי רכב שהמערכת מתעלמת ממנו ב-injectedSolutionConstraint וכל איסוף או מסירה קשורים מוגבלים להישאר ברכב (כלומר, לא הוקלו לרמה RELAX_ALL_AFTER_THRESHOLD), המערכת מדלגת עליהם בתגובה. אם למשלוח יש שדה allowedVehicleIndices לא ריק וכל כלי הרכב המותרים נמחקים, המערכת מדלגת עליו בתגובה.
travelDurationMultiple

number

מציין גורם כפל שאפשר להשתמש בו כדי להגדיל או להקטין את זמני הנסיעה של הרכב הזה. לדוגמה, אם מגדירים את הערך 2.0, הרכב הזה איטי יותר וזמני הנסיעה שלו ארוכים פי שניים מאלה של רכבים רגילים. הכפולה הזו לא משפיעה על משך הביקור. היא משפיעה על העלות אם מציינים את costPerHour או את costPerTraveledHour. הערך חייב להיות בטווח [0.001, 1000.0]. אם לא מגדירים את המכפיל, הרכב נחשב כרכב רגיל והמכפיל הוא 1.0.

אזהרה: זמני הנסיעה יעוגלו לשנייה הקרובה ביותר אחרי החלת הכפולה הזו, אבל לפני ביצוע פעולות מספריות כלשהן. לכן, כפולה קטנה עלולה לגרום לאובדן דיוק.

מידע נוסף מופיע בקטע extraVisitDurationForVisitType בהמשך.

TravelMode

אמצעי תחבורה שמתאימים לכלי רכב.

אלה צריכים להיות קבוצת משנה של אמצעי ההגעה של Routes API ב-Google Maps Platform, ראו: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode

הערה: מסלולי WALKING נמצאים בגרסת בטא, ולפעמים חסרות בהם מדרכות או דרכים להולכי רגל. חובה להציג את האזהרה הזו למשתמש בכל מסלולי ההליכה שמוצגים באפליקציה.

טיפוסים בני מנייה (enum)
TRAVEL_MODE_UNSPECIFIED אמצעי הגעה לא מוגדר, שווה ערך ל-DRIVING.
DRIVING אמצעי הגעה שתואם למסלול נסיעה (רכב, ...).
WALKING אמצעי הגעה שתואם למסלול הליכה.
TWO_WHEELER רכב דו-גלגלי ממונע. לדוגמה, אופנוע. חשוב לשים לב שהאפשרות הזו שונה מאמצעי ההגעה "רכיבה על אופניים", שכולל אמצעי הגעה שמופעלים על ידי בני אדם.

RouteModifiers

מכיל קבוצה של תנאים אופציונליים שצריך לעמוד בהם כשמחשבים מסלולים של כלי רכב. השדה הזה דומה לשדה RouteModifiers ב-Routes Preferred API של הפלטפורמה של מפות Google. מידע נוסף זמין בכתובת: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers.

ייצוג ב-JSON 
{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}
שדות
avoidTolls

boolean

ההגדרה קובעת אם להימנע מכבישי אגרה כשאפשר. תינתן עדיפות למסלולים שלא כוללים כבישי אגרה. רלוונטי רק לאמצעי תחבורה ממונעים.
avoidHighways

boolean

מציינת אם להימנע מכבישים מהירים כשאפשר. תינתן עדיפות למסלולים שלא כוללים כבישים מהירים. רלוונטי רק לאמצעי תחבורה ממונעים.
avoidFerries

boolean

ההגדרה קובעת אם להימנע ממעבורות כשאפשר. תינתן עדיפות למסלולים שלא כוללים נסיעה במעבורות. רלוונטי רק לאמצעי תחבורה ממונעים.
avoidIndoor

boolean

אופציונלי. המדיניות קובעת אם להימנע מניווט בתוך מבנים כשאפשר. תינתן עדיפות למסלולים שלא כוללים ניווט בתוך מבנים. ההגדרה חלה רק על אופן הנסיעה WALKING.

UnloadingPolicy

המדיניות לגבי פריקת רכב. רלוונטי רק למשלוחים שכוללים גם איסוף וגם מסירה.

משלוחים אחרים יכולים להתבצע בכל מקום במסלול, בלי קשר ל-unloadingPolicy.

טיפוסים בני מנייה (enum)
UNLOADING_POLICY_UNSPECIFIED מדיניות פריקה לא מוגדרת. המשלוחים צריכים להתבצע רק אחרי האיסופים התואמים שלהם.
LAST_IN_FIRST_OUT המשלוחים צריכים להתבצע בסדר הפוך מהאיסופים
FIRST_IN_FIRST_OUT המשלוחים צריכים להתבצע באותו סדר כמו האיסופים

LoadLimit

מגדיר מגבלת עומס שחלה על רכב, למשל "המשאית הזו יכולה לשאת עד 3,500 ק"ג". loadLimits.

ייצוג ב-JSON 
{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string,
  "costPerKilometer": {
    object (LoadCost)
  },
  "costPerTraveledHour": {
    object (LoadCost)
  }
}
שדות
softMaxLoad

string (int64 format)

מגבלה גמישה של העומס. costPerUnitAboveSoftMax.
costPerUnitAboveSoftMax

number

אם העומס חורג מהערך softMaxLoad לאורך המסלול של הרכב הזה, חל הקנס הבא (רק פעם אחת לכל רכב): (עומס - softMaxLoad) * costPerUnitAboveSoftMax. כל העלויות מצטברות וצריכות להיות באותה יחידה כמו Shipment.penalty_cost. אפשר להגדיר מגבלות גמישות רק בסוגים שחלים על איסופים בלבד או על משלוחים בלבד בכל המודל.
startLoadInterval

object (Interval)

מרווח העומס הקביל של הרכב בתחילת המסלול.
endLoadInterval

object (Interval)

מרווח העומס הקביל של הרכב בסוף המסלול.
maxLoad

string (int64 format)

העומס המקסימלי המותר.
costPerKilometer

object (LoadCost)

עלות ההעברה של יחידת מטען אחת לאורך קילומטר אחד ברכב הזה. אפשר להשתמש בזה כפרוקסי לצריכת דלק: אם העומס הוא משקל (בניוטונים), אז עומס*קילומטר הוא ממד של אנרגיה.

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.
costPerTraveledHour

object (LoadCost)

עלות הנסיעה עם יחידת מטען במשך שעה אחת ברכב הזה.

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

מרווח

טווח של סכומי טעינה קבילים.

ייצוג ב-JSON 
{
  "min": string,
  "max": string
}
שדות
min

string (int64 format)

עומס מינימלי קביל. הערך חייב להיות גדול מ-0 או שווה לו. אם שניהם צוינו, הערך של min חייב להיות קטן או שווה לערך של max.
max

string (int64 format)

עומס מקסימלי מקובל. הערך חייב להיות גדול מ-0 או שווה לו. אם לא מציינים ערך, העומס המקסימלי לא מוגבל על ידי ההודעה הזו. אם שניהם צוינו, הערך של min חייב להיות קטן או שווה לערך של max.

LoadCost

עלות ההעברה של יחידת עומס אחת במהלך Transition. העלות של עומס נתון היא הסכום של שני חלקים:

  • min(load, loadThreshold) * costPerUnitBelowThreshold
  • max(0, load - loadThreshold) * costPerUnitAboveThreshold

עם העלות הזו, הפתרונות מעדיפים לספק קודם את הביקושים הגבוהים, או באופן שווה ערך לאסוף את הביקושים הגבוהים אחרונים. לדוגמה, אם לרכב יש

load_limit {
  key: "weight"
  value {
    costPerKilometer {
      loadThreshold: 15
      costPerUnitBelowThreshold: 2.0
      costPerUnitAboveThreshold: 10.0
    }
  }
}

והמסלול שלו הוא: התחלה, איסוף, איסוף, מסירה, מסירה, סיום, עם המעברים הבאים:

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 20 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

אז העלות של LoadCost היא (cost_below * load_below * kilometers + cost_above * load_above * kms)

  • מעבר 0: 0.0
  • מעבר 1: ‎2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 2: ‎2.0 * 15 * 1.0 + 10.0 * (20 - 15) * 1.0 = 80.0
  • מעבר 3: ‎2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 4: 0.0

לכן, הערך של LoadCost לאורך המסלול הוא 120.0.

לעומת זאת, אם המסלול הוא התחלה,איסוף,מסירה,איסוף,מסירה,סיום עם מעברים:

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

אז העלות שנוצרה על ידי LoadCost היא

  • מעבר 0: 0.0
  • מעבר 1: ‎2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 2: 0.0
  • מעבר 3: ‎2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 4: 0.0

כאן הערך של LoadCost במסלול הוא 40.0.

LoadCost מייקרת פתרונות עם מעברים עמוסים.

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

ייצוג ב-JSON 
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
שדות
loadThreshold

string (int64 format)

כמות העומס שמעליה העלות של העברת יחידת עומס משתנה מ-costPerUnitBelowThreshold ל-costPerUnitAboveThreshold. הערך חייב להיות גדול מ-0 או שווה לו.
costPerUnitBelowThreshold

number

עלות ההעברה של יחידת עומס, לכל יחידה בין 0 לערך הסף. הערך חייב להיות סופי וגדול מ-0 או שווה לו.
costPerUnitAboveThreshold

number

עלות ההעברה של יחידת עומס, לכל יחידה מעל הסף. במקרה המיוחד שבו הסף = 0, זו עלות קבועה ליחידה. הערך חייב להיות סופי וגדול מ-0 או שווה לו.

DurationLimit

מגבלה שמגדירה את משך הזמן המקסימלי של מסלול הרכב. הוא יכול להיות קשיח או רך.

כשמגדירים שדה של מגבלה גמישה, צריך להגדיר גם את הסף המקסימלי הגמיש וגם את העלות שמשויכת אליו.

ייצוג ב-JSON 
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
שדות
maxDuration

string (Duration format)

מגבלה קשיחה שמגבילה את משך הזמן ל-maxDuration לכל היותר.
softMaxDuration

string (Duration format)

מגבלה גמישה שלא אוכפת מגבלה על משך הזמן המקסימלי, אבל אם חורגים ממנה, המסלול כרוך בעלות. העלות הזו מתווספת לעלויות אחרות שמוגדרות במודל, באותה יחידה.

אם מגדירים את softMaxDuration, הערך שלו לא יכול להיות שלילי. אם גם maxDuration מוגדר, softMaxDuration חייב להיות קטן מ-maxDuration.
quadraticSoftMaxDuration

string (Duration format)

מגבלה גמישה שלא אוכפת מגבלת משך מקסימלי, אבל אם חורגים ממנה, המסלול כרוך בעלות ריבועית ביחס למשך. העלות הזו מתווספת לעלויות אחרות שמוגדרות במודל, באותה יחידה.

אם השדה quadraticSoftMaxDuration מוגדר, התנאים הבאים צריכים להתקיים:

  • הערך לא יכול להיות שלילי.
  • חובה להגדיר את maxDuration.
  • הערך של quadraticSoftMaxDuration חייב להיות קטן מהערך של maxDuration.
  • ההפרש לא יכול להיות יותר מיום אחד: maxDuration - quadraticSoftMaxDuration <= 86400 seconds
costPerHourAfterSoftMax

number

העלות לשעה שתיצבר אם תהיה חריגה מהסף של softMaxDuration. העלות הנוספת היא 0 אם משך הזמן נמוך מהסף, אחרת העלות תלויה במשך הזמן באופן הבא:

  costPerHourAfterSoftMax * (duration - softMaxDuration)

העלות לא יכולה להיות שלילית.
costPerSquareHourAfterQuadraticSoftMax

number

העלות לשעה בריבוע שנגבית אם חורגים מהסף של quadraticSoftMaxDuration.

העלות הנוספת היא 0 אם משך הזמן נמוך מהסף, אחרת העלות תלויה במשך הזמן באופן הבא:

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

העלות לא יכולה להיות שלילית.

DistanceLimit

מגבלה שמגדירה את המרחק המקסימלי שאפשר לנסוע. הוא יכול להיות קשיח או רך.

אם מגדירים מגבלה גמישה, צריך להגדיר גם את softMaxMeters וגם את costPerKilometerAboveSoftMax, והערכים שלהם לא יכולים להיות שליליים.

ייצוג ב-JSON 
{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}
שדות
maxMeters

string (int64 format)

מגבלה קשיחה שמגבילה את המרחק ל-maxMeters לכל היותר. הסף חייב להיות מספר חיובי.
softMaxMeters

string (int64 format)

מגבלה גמישה שלא אוכפת מגבלת מרחק מקסימלי, אבל אם חורגים ממנה, היא מוסיפה עלות לעלויות אחרות שמוגדרות במודל, באותה יחידה.

אם מגדירים את softMaxMeters, הערך צריך להיות קטן מ-maxMeters ולא שלילי.
costPerKilometerBelowSoftMax

number

העלות לקילומטר שנצברה, עד softMaxMeters, לפי הנוסחה:

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

העלות הזו לא נתמכת ב-routeDistanceLimit.
costPerKilometerAboveSoftMax

number

עלות לקילומטר אם המרחק חורג מהמגבלה של softMaxMeters. העלות הנוספת היא 0 אם המרחק קטן מהמגבלה, אחרת הנוסחה שמשמשת לחישוב העלות היא:

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

העלות לא יכולה להיות שלילית.

BreakRule

כללים ליצירת הפסקות לרכב (למשל, הפסקות צהריים). הפסקה היא פרק זמן רציף שבו הרכב נשאר במצב חוסר פעילות במיקום הנוכחי שלו ולא יכול לבצע שום ביקור. הפסקה יכולה להתרחש:

  • במהלך הנסיעה בין שני ביקורים (כולל הזמן ממש לפני או ממש אחרי ביקור, אבל לא באמצע ביקור), ובמקרה כזה הוא מאריך את זמן ההובלה המתאים בין הביקורים,
  • או לפני שהרכב מתחיל לנסוע (הרכב לא יכול להתחיל לנסוע באמצע הפסקה), ובמקרה כזה היא לא משפיעה על שעת ההתחלה של הרכב.
  • או אחרי שעת הסיום של הרכב (כנ"ל, עם שעת הסיום של הרכב).
ייצוג ב-JSON 
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
שדות
breakRequests[]

object (BreakRequest)

רצף של הפסקות. ההודעה BreakRequest.
frequencyConstraints[]

object (FrequencyConstraint)

יכול להיות שיחולו כמה FrequencyConstraint. כל התנאים צריכים להתקיים על ידי ה-BreakRequest של ה-BreakRule הזה. FrequencyConstraint.

BreakRequest

צריך לדעת מראש את רצף ההפסקות (כלומר, המספר והסדר שלהן) שחלות על כל רכב. הערכים החוזרים של BreakRequest מגדירים את הרצף הזה, לפי הסדר שבו הם צריכים להתרחש. חלונות הזמן שלהם (earliestStartTime / latestStartTime) יכולים לחפוף, אבל הם חייבים להתאים להזמנה (זה נבדק).

ייצוג ב-JSON 
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
שדות
earliestStartTime

string (Timestamp format)

חובה. הגבול התחתון (כולל) של תחילת ההפסקה.

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
latestStartTime

string (Timestamp format)

חובה. הגבול העליון (כולל) של תחילת ההפסקה.

הפורמט הוא RFC 3339, והפלט שנוצר תמיד יהיה מנורמל ל-Z וישתמש ב-0, 3, 6 או 9 ספרות אחרי הנקודה העשרונית. אפשר להשתמש גם בהיסטים אחרים, לא רק ב-Z. לדוגמה: "2014-10-02T15:01:23Z",‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
minDuration

string (Duration format)

חובה. משך הזמן המינימלי של ההפסקה. הערך חייב להיות חיובי.

FrequencyConstraint

אפשר להגביל עוד יותר את התדירות ומשך הזמן של ההפסקות שצוינו למעלה, על ידי אכיפת תדירות הפסקות מינימלית, כמו "חייבת להיות הפסקה של שעה אחת לפחות כל 12 שעות". נניח שאפשר לפרש את זה כך: "בכל חלון זמן של 12 שעות, חייבת להיות הפסקה אחת לפחות של שעה אחת לפחות". הדוגמה הזו תתורגם ל-FrequencyConstraint הבא:

{
   minBreakDuration { seconds: 3600 }         # 1 hour.
   maxInterBreakDuration { seconds: 39600 }  # 11 hours (12 - 1 = 11).
}

התזמון ומשך ההפסקות בפתרון יתחשבו בכל המגבלות האלה, בנוסף לחלונות הזמן ולמשכי הזמן המינימליים שכבר צוינו ב-BreakRequest.

בפועל, FrequencyConstraint עשויה לחול על הפסקות לא רצופות. לדוגמה, לוח הזמנים הבא תואם לדוגמה "שעה אחת כל 12 שעות":

  04:00 vehicle start
   .. performing travel and visits ..
  09:00 1 hour break
  10:00 end of the break
   .. performing travel and visits ..
  12:00 20-min lunch break
  12:20 end of the break
   .. performing travel and visits ..
  21:00 1 hour break
  22:00 end of the break
   .. performing travel and visits ..
  23:59 vehicle end
ייצוג ב-JSON 
{
  "minBreakDuration": string,
  "maxInterBreakDuration": string
}
שדות
minBreakDuration

string (Duration format)

חובה. משך ההפסקה המינימלי לאילוץ הזה. לא שלילי. הצגת התיאור של FrequencyConstraint.
maxInterBreakDuration

string (Duration format)

חובה. משך הזמן המקסימלי המותר לכל מרווח זמן במסלול שלא כולל הפסקה של duration >= minBreakDuration, לפחות באופן חלקי. הערך חייב להיות חיובי.

מטרה

היעדים מחליפים את מודל העלות לחלוטין, ולכן הם לא תואמים לעלויות קיימות. כל מטרה ממופה למספר עלויות מוגדרות מראש, למשל, כלי רכב, משלוחים או מאפייני מעבר.

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.

ייצוג ב-JSON 
{
  "type": enum (Type),
  "weight": number
}
שדות
type

enum (Type)

סוג היעד.
weight

number

כמה היעד הזה צריך להיחשב ביחס ליעדים האחרים. אפשר להזין כל מספר לא שלילי, וסכום המשקלים לא חייב להיות 1. ברירת המחדל של המשקלים היא 1.0.

סוג

סוג היעד שימופה לקבוצת עלויות.

טיפוסים בני מנייה (enum)
DEFAULT כדי להבטיח פתרון סביר, המערכת תשתמש בקבוצת עלויות שמוגדרת כברירת מחדל. הערה: אפשר להשתמש ביעד הזה בפני עצמו, אבל הוא גם תמיד יתווסף עם משקל 1.0, כבסיס, ליעדים שהמשתמש ציין, אם הוא עדיין לא קיים.
MIN_DISTANCE יעדי MIN. לצמצם את המרחק הכולל.
MIN_WORKING_TIME צמצום זמן העבודה הכולל, בחישוב של כל הרכבים.
MIN_TRAVEL_TIME כמו למעלה, אבל עם התמקדות בזמן הנסיעה בלבד.
MIN_NUM_VEHICLES לצמצם את מספר כלי הרכב שבהם משתמשים.

DurationDistanceMatrix

מציינת מטריצה של משך זמן ומרחק ממיקומי ההתחלה של הביקור והרכב למיקומי הסיום של הביקור והרכב.

ייצוג ב-JSON 
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
שדות
rows[]

object (Row)

מציין את השורות של מטריצת משך הזמן ומטריצת המרחקים. הוא חייב להכיל את אותו מספר רכיבים כמו ShipmentModel.duration_distance_matrix_src_tags.
vehicleStartTag

string

תג שמגדיר על אילו רכבים חלה מטריצת המרחקים ומשך הזמן הזו. אם לא מציינים ערך, המטריצה חלה על כל הרכבים, ויכולה להיות רק מטריצה אחת.

כל נקודת התחלה של רכב חייבת להתאים בדיוק למטריצה אחת, כלומר בדיוק אחד משדות ה-startTags שלה חייב להתאים ל-vehicleStartTag של מטריצה (ורק של המטריצה הזו).

לכל המטריצות צריך להיות vehicleStartTag שונה.

שורה

מציין שורה במטריצת משך הזמן והמרחק.

ייצוג ב-JSON 
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
שדות
durations[]

string (Duration format)

ערכי משך הזמן בשורה נתונה. הוא חייב להכיל את אותו מספר רכיבים כמו ShipmentModel.duration_distance_matrix_dst_tags.
meters[]

number

ערכי המרחק בשורה נתונה. אם אין עלויות או אילוצים שמתייחסים למרחקים במודל, אפשר להשאיר את השדה הזה ריק. אחרת, הוא חייב להכיל מספר רכיבים זהה ל-durations.

TransitionAttributes

מציין מאפיינים של מעברים בין שני ביקורים רצופים במסלול. יכול להיות שכמה TransitionAttributes יחולו על אותו מעבר: במקרה כזה, כל העלויות הנוספות מצטברות והאילוץ או המגבלה המחמירים ביותר חלים (בהתאם לסמנטיקה הטבעית של "AND").

ייצוג ב-JSON 
{
  "srcTag": string,
  "excludedSrcTag": string,
  "dstTag": string,
  "excludedDstTag": string,
  "cost": number,
  "costPerKilometer": number,
  "distanceLimit": {
    object (DistanceLimit)
  },
  "delay": string
}
שדות
srcTag

string

תגים שמגדירים את קבוצת המעברים (src->dst) שהמאפיינים האלה חלים עליהם.

ביקור במקור או התחלה של רכב תואמים אם ורק אם השדה VisitRequest.tags או Vehicle.start_tags מכיל את srcTag או לא מכיל את excludedSrcTag (בהתאם לשדה מבין השניים שלא ריק).
excludedSrcTag

string

srcTag. אחד מהשדות srcTag ו-excludedSrcTag חייב להיות לא ריק.
dstTag

string

ביקור ביעד או סיום נסיעה ברכב תואמים אם השדה VisitRequest.tags או Vehicle.end_tags מכיל את dstTag או לא מכיל את excludedDstTag (בהתאם לשדה מבין השניים שלא ריק).
excludedDstTag

string

dstTag. אחד מהשדות dstTag ו-excludedDstTag חייב להיות לא ריק.
cost

number

מציין את העלות של ביצוע המעבר הזה. הערך הזה צריך להיות באותה יחידה כמו כל העלויות האחרות במודל, והוא לא יכול להיות שלילי. הוא מתווסף לכל העלויות הקיימות האחרות.
costPerKilometer

number

מציין עלות לקילומטר שחלה על המרחק שנעשה במהלך המעבר הזה. הוא מצטבר לכל Vehicle.cost_per_kilometer שצוין ברכבים.
distanceLimit

object (DistanceLimit)

מציינת מגבלה על המרחק שהרכב יכול לעבור בזמן ביצוע המעבר הזה.

נכון ליוני 2021, יש תמיכה רק במגבלות גמישות.
delay

string (Duration format)

מציין את העיכוב שנגרם כשמבצעים את המעבר הזה.

העיכוב הזה תמיד מתרחש אחרי סיום הביקור בנקודת המוצא ולפני תחילת הביקור בנקודת היעד.

ShipmentTypeIncompatibility

מציין חוסר תאימות בין משלוחים בהתאם ל-shipmentType שלהם. ההופעה של משלוחים לא תואמים באותו מסלול מוגבלת בהתאם למצב חוסר התאימות.

ייצוג ב-JSON 
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
שדות
types[]

string

רשימה של סוגים לא תואמים. שני משלוחים עם ערכים שונים של shipment_types מבין אלה שברשימה נחשבים "לא תואמים".
incompatibilityMode

enum (IncompatibilityMode)

המצב שמופעל על חוסר התאימות.

IncompatibilityMode

מצבים שמגדירים איך להגביל את ההופעה של משלוחים לא תואמים באותו מסלול.

טיפוסים בני מנייה (enum)
INCOMPATIBILITY_MODE_UNSPECIFIED מצב אי-תאימות לא מוגדר. אין להשתמש בערך הזה.
NOT_PERFORMED_BY_SAME_VEHICLE במצב הזה, שני משלוחים עם סוגים לא תואמים לא יכולים לחלוק את אותו הרכב.
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

במצב הזה, שני משלוחים עם סוגים לא תואמים לא יכולים להיות באותו רכב באותו זמן:

  • הם יכולים לחלוק את אותו הרכב רק אם אחד מהם מגיע ליעד לפני שהשני נאסף.
  • אם שני המשלוחים הם איסופים בלבד (ללא מסירות) או מסירות בלבד (ללא איסופים), הם לא יכולים לחלוק את אותו הרכב בכלל.

ShipmentTypeRequirement

מציין את הדרישות בין משלוחים על סמך ה-shipmentType שלהם. הפרטים הספציפיים של הדרישה מוגדרים לפי מצב הדרישה.

ייצוג ב-JSON 
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
שדות
requiredShipmentTypeAlternatives[]

string

רשימה של סוגי משלוחים חלופיים שנדרשים על ידי dependentShipmentTypes.
dependentShipmentTypes[]

string

כל המשלוחים עם סוג בשדה dependentShipmentTypes דורשים ביקור במשלוח אחד לפחות מסוג requiredShipmentTypeAlternatives באותו מסלול.

הערה: אסור ליצור שרשראות של דרישות שבהן shipmentType תלוי בעצמו.
requirementMode

enum (RequirementMode)

המצב שמוגדר לדרישה.

RequirementMode

מצבים שמגדירים את המראה של משלוחים תלויים במסלול.

טיפוסים בני מנייה (enum)
REQUIREMENT_MODE_UNSPECIFIED מצב דרישה לא מוגדר. אין להשתמש בערך הזה.
PERFORMED_BY_SAME_VEHICLE במצב הזה, כל המשלוחים "התלויים" חייבים לחלוק את אותו הרכב עם לפחות אחד מהמשלוחים "הנדרשים" שלהם.
IN_SAME_VEHICLE_AT_PICKUP_TIME

במצב IN_SAME_VEHICLE_AT_PICKUP_TIME, כל המשלוחים "התלויים" צריכים לכלול לפחות משלוח אחד "נדרש" ברכב בזמן האיסוף.

לכן, איסוף משלוח "תלוי" חייב לכלול:

  • משלוח "חובה" למסירה בלבד שנמסר במסלול אחריו, או
  • משלוח "נדרש" נאסף במסלול לפניו, ואם למשלוח ה"נדרש" יש מסירה, המסירה הזו חייבת להתבצע אחרי האיסוף של המשלוח ה"תלוי".
IN_SAME_VEHICLE_AT_DELIVERY_TIME כמו קודם, אבל המשלוחים "התלויים" צריכים להיות ברכב עם משלוח "נדרש" בזמן המסירה שלהם.

PrecedenceRule

כלל קדימות בין שני אירועים (כל אירוע הוא איסוף או מסירה של משלוח): האירוע "השני" צריך להתחיל לפחות offsetDuration אחרי שהאירוע "הראשון" התחיל.

כמה קדימויות יכולות להתייחס לאותם אירועים (או לאירועים קשורים), למשל, "האיסוף של B מתרחש אחרי המסירה של A" ו "האיסוף של C מתרחש אחרי האיסוף של B".

בנוסף, קדימויות חלות רק כששני המשלוחים מבוצעים, ואחרת המערכת מתעלמת מהן.

ייצוג ב-JSON 
{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}
שדות
firstIsDelivery

boolean

מציין אם האירוע "הראשון" הוא מסירה.
secondIsDelivery

boolean

מציין אם האירוע "השני" הוא מסירה.
offsetDuration

string (Duration format)

ההפרש בין האירוע "הראשון" לאירוע "השני". הוא יכול להיות שלילי.
firstIndex

integer

אינדקס המשלוח של האירוע "הראשון". חובה למלא את השדה הזה.
secondIndex

integer

אינדקס המשלוח של האירוע "השני". חובה למלא את השדה הזה.