ShipmentModel

{
  "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
}

string

The user-defined display name of the shipment. It can be up to 63 characters long and may use UTF-8 characters.

object (VisitRequest)

Set of pickup alternatives associated to the shipment. If not specified, the vehicle only needs to visit a location corresponding to the deliveries.

object (VisitRequest)

Set of delivery alternatives associated to the shipment. If not specified, the vehicle only needs to visit a location corresponding to the pickups.

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

Load demands of the shipment (for example weight, volume, number of pallets etc). The keys in the map should be identifiers describing the type of the corresponding load, ideally also including the units. For example: "weight_kg", "volume_gallons", "pallet_count", etc. If a given key does not appear in the map, the corresponding load is considered as null.

integer

The set of vehicles that may perform this shipment. If empty, all vehicles may perform it. Vehicles are given by their index in the ShipmentModel's vehicles list.

number

Specifies the cost that is incurred when this shipment is delivered by each vehicle. If specified, it must have EITHER:

• the same number of elements as costsPerVehicleIndices. costsPerVehicle[i] corresponds to vehicle costsPerVehicleIndices[i] of the model.
• the same number of elements as there are vehicles in the model. The i-th element corresponds to vehicle #i of the model.

These costs must be in the same unit as penaltyCost and must not be negative. Leave this field empty, if there are no such costs.

integer

Indices of the vehicles to which costsPerVehicle applies. If non-empty, it must have the same number of elements as costsPerVehicle. A vehicle index may not be specified more than once. If a vehicle is excluded from costsPerVehicleIndices, its cost is zero.

string (Duration format)

Specifies the maximum absolute detour time compared to the shortest path from pickup to delivery. If specified, it must be nonnegative, and the shipment must contain at least a pickup and a delivery.

For example, let t be the shortest time taken to go from the selected pickup alternative directly to the selected delivery alternative. Then setting pickupToDeliveryAbsoluteDetourLimit enforces:

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

If both relative and absolute limits are specified on the same shipment, the more constraining limit is used for each possible pickup/delivery pair. As of 2017/10, detours are only supported when travel durations do not depend on vehicles.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

string (Duration format)

Specifies the maximum duration from start of pickup to start of delivery of a shipment. If specified, it must be nonnegative, and the shipment must contain at least a pickup and a delivery. This does not depend on which alternatives are selected for pickup and delivery, nor on vehicle speed. This can be specified alongside maximum detour constraints: the solution will respect both specifications.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

string

Non-empty string specifying a "type" for this shipment. This feature can be used to define incompatibilities or requirements between shipment_types (see shipmentTypeIncompatibilities and shipmentTypeRequirements in ShipmentModel).

Differs from visitTypes which is specified for a single visit: All pickup/deliveries belonging to the same shipment share the same shipmentType.

string

Specifies a label for this shipment. This label is reported in the response in the shipmentLabel of the corresponding ShipmentRoute.Visit.

boolean

If true, skip this shipment, but don't apply a penaltyCost.

Ignoring a shipment results in a validation error when there are any shipmentTypeRequirements in the model.

Ignoring a shipment that is performed in injectedFirstSolutionRoutes or injectedSolutionConstraint is permitted; the solver removes the related pickup/delivery visits from the performing route. precedenceRules that reference ignored shipments will also be ignored.

number

If the shipment is not completed, this penalty is added to the overall cost of the routes. A shipment is considered completed if one of its pickup and delivery alternatives is visited. The cost may be expressed in the same unit used for all other cost-related fields in the model and must be positive.

IMPORTANT: If this penalty is not specified, it is considered infinite, i.e. the shipment must be completed.

number

Specifies the maximum relative detour time compared to the shortest path from pickup to delivery. If specified, it must be nonnegative, and the shipment must contain at least a pickup and a delivery.

For example, let t be the shortest time taken to go from the selected pickup alternative directly to the selected delivery alternative. Then setting pickupToDeliveryRelativeDetourLimit enforces:

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

If both relative and absolute limits are specified on the same shipment, the more constraining limit is used for each possible pickup/delivery pair. As of 2017/10, detours are only supported when travel durations do not depend on vehicles.

{
  "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
}

object (LatLng)

The geo-location where the vehicle arrives when performing this VisitRequest. If the shipment model has duration distance matrices, arrivalLocation must not be specified.

object (Waypoint)

The waypoint where the vehicle arrives when performing this VisitRequest. If the shipment model has duration distance matrices, arrivalWaypoint must not be specified.

object (LatLng)

The geo-location where the vehicle departs after completing this VisitRequest. Can be omitted if it is the same as arrivalLocation. If the shipment model has duration distance matrices, departureLocation must not be specified.

object (Waypoint)

The waypoint where the vehicle departs after completing this VisitRequest. Can be omitted if it is the same as arrivalWaypoint. If the shipment model has duration distance matrices, departureWaypoint must not be specified.

string

Specifies tags attached to the visit request. Empty or duplicate strings are not allowed.

object (TimeWindow)

Time windows which constrain the arrival time at a visit. Note that a vehicle may depart outside of the arrival time window, i.e. arrival time + duration do not need to be inside a time window. This can result in waiting time if the vehicle arrives before TimeWindow.start_time.

The absence of TimeWindow means that the vehicle can perform this visit at any time.

Time windows must be disjoint, i.e. no time window must overlap with or be adjacent to another, and they must be in increasing order.

costPerHourAfterSoftEndTime and softEndTime can only be set if there is a single time window.

string (Duration format)

Duration of the visit, i.e. time spent by the vehicle between arrival and departure (to be added to the possible waiting time; see timeWindows).

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

number

Cost to service this visit request on a vehicle route. This can be used to pay different costs for each alternative pickup or delivery of a shipment. This cost must be in the same unit as Shipment.penalty_cost and must not be negative.

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

Load demands of this visit request. This is just like Shipment.load_demands field, except that it only applies to this VisitRequest instead of the whole Shipment. The demands listed here are added to the demands listed in Shipment.load_demands.

string

Specifies the types of the visit. This may be used to allocate additional time required for a vehicle to complete this visit (see Vehicle.extra_visit_duration_for_visit_type).

A type can only appear once.

string

Specifies a label for this VisitRequest. This label is reported in the response as visitLabel in the corresponding ShipmentRoute.Visit.

{
  "latitude": number,
  "longitude": number
}

number

The latitude in degrees. It must be in the range [-90.0, +90.0].

number

The longitude in degrees. It must be in the range [-180.0, +180.0].

{
  "sideOfRoad": boolean,

  // Union field location_type can be only one of the following:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of list of possible types for union field location_type.
}

boolean

Optional. Indicates that the location of this waypoint is meant to have a preference for the vehicle to stop at a particular side of road. When you set this value, the route will pass through the location so that the vehicle can stop at the side of road that the location is biased towards from the center of the road. This option doesn't work for the 'WALKING' travel mode.

object (Location)

A point specified using geographic coordinates, including an optional heading.

string

The POI Place ID associated with the waypoint.

{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}

object (LatLng)

The waypoint's geographic coordinates.

integer

The compass heading associated with the direction of the flow of traffic. This value is used to specify the side of the road to use for pickup and drop-off. Heading values can be from 0 to 360, where 0 specifies a heading of due North, 90 specifies a heading of due East, etc.

{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}

string (Timestamp format)

The hard time window start time. If unspecified it will be set to ShipmentModel.global_start_time.

A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

string (Timestamp format)

The hard time window end time. If unspecified it will be set to ShipmentModel.global_end_time.

A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

string (Timestamp format)

The soft start time of the time window.

A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

string (Timestamp format)

The soft end time of the time window.

A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

number

A cost per hour added to other costs in the model if the event occurs before softStartTime, computed as:

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

This cost must be positive, and the field can only be set if softStartTime has been set.

number

A cost per hour added to other costs in the model if the event occurs after softEndTime, computed as:

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

This cost must be positive, and the field can only be set if softEndTime has been set.

{
  "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
}

string

The user-defined display name of the vehicle. It can be up to 63 characters long and may use UTF-8 characters.

enum (TravelMode)

The travel mode which affects the roads usable by the vehicle and its speed. See also travelDurationMultiple.

object (RouteModifiers)

A set of conditions to satisfy that affect the way routes are calculated for the given vehicle.

object (LatLng)

Geographic location where the vehicle starts before picking up any shipments. If not specified, the vehicle starts at its first pickup. If the shipment model has duration and distance matrices, startLocation must not be specified.

object (Waypoint)

Waypoint representing a geographic location where the vehicle starts before picking up any shipments. If neither startWaypoint nor startLocation is specified, the vehicle starts at its first pickup. If the shipment model has duration and distance matrices, startWaypoint must not be specified.

object (LatLng)

Geographic location where the vehicle ends after it has completed its last VisitRequest. If not specified the vehicle's ShipmentRoute ends immediately when it completes its last VisitRequest. If the shipment model has duration and distance matrices, endLocation must not be specified.

object (Waypoint)

Waypoint representing a geographic location where the vehicle ends after it has completed its last VisitRequest. If neither endWaypoint nor endLocation is specified, the vehicle's ShipmentRoute ends immediately when it completes its last VisitRequest. If the shipment model has duration and distance matrices, endWaypoint must not be specified.

string

Specifies tags attached to the start of the vehicle's route.

Empty or duplicate strings are not allowed.

string

Specifies tags attached to the end of the vehicle's route.

Empty or duplicate strings are not allowed.

object (TimeWindow)

Time windows during which the vehicle may depart its start location. They must be within the global time limits (see ShipmentModel.global_* fields). If unspecified, there is no limitation besides those global time limits.

Time windows belonging to the same repeated field must be disjoint, i.e. no time window can overlap with or be adjacent to another, and they must be in chronological order.

costPerHourAfterSoftEndTime and softEndTime can only be set if there is a single time window.

object (TimeWindow)

Time windows during which the vehicle may arrive at its end location. They must be within the global time limits (see ShipmentModel.global_* fields). If unspecified, there is no limitation besides those global time limits.

Time windows belonging to the same repeated field must be disjoint, i.e. no time window can overlap with or be adjacent to another, and they must be in chronological order.

costPerHourAfterSoftEndTime and softEndTime can only be set if there is a single time window.

enum (UnloadingPolicy)

Unloading policy enforced on the vehicle.

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

Capacities of the vehicle (weight, volume, # of pallets for example). The keys in the map are the identifiers of the type of load, consistent with the keys of the Shipment.load_demands field. If a given key is absent from this map, the corresponding capacity is considered to be limitless.

number

Vehicle costs: all costs add up and must be in the same unit as Shipment.penalty_cost.

Cost per hour of the vehicle route. This cost is applied to the total time taken by the route, and includes travel time, waiting time, and visit time. Using costPerHour instead of just costPerTraveledHour may result in additional latency.

number

Cost per traveled hour of the vehicle route. This cost is applied only to travel time taken by the route (i.e., that reported in ShipmentRoute.transitions), and excludes waiting time and visit time.

number

Cost per kilometer of the vehicle route. This cost is applied to the distance reported in the ShipmentRoute.transitions and does not apply to any distance implicitly traveled from the arrivalLocation to the departureLocation of a single VisitRequest.

number

Fixed cost applied if this vehicle is used to handle a shipment.

boolean

This field only applies to vehicles when their route does not serve any shipments. It indicates if the vehicle should be considered as used or not in this case.

If true, the vehicle goes from its start to its end location even if it doesn't serve any shipments, and time and distance costs resulting from its start --> end travel are taken into account.

Otherwise, it doesn't travel from its start to its end location, and no breakRule or delay (from TransitionAttributes) are scheduled for this vehicle. In this case, the vehicle's ShipmentRoute doesn't contain any information except for the vehicle index and label.

object (DurationLimit)

Limit applied to the total duration of the vehicle's route. In a given OptimizeToursResponse, the route duration of a vehicle is the difference between its vehicleEndTime and vehicleStartTime.

object (DurationLimit)

Limit applied to the travel duration of the vehicle's route. In a given OptimizeToursResponse, the route travel duration is the sum of all its transitions.travel_duration.

object (DistanceLimit)

Limit applied to the total distance of the vehicle's route. In a given OptimizeToursResponse, the route distance is the sum of all its transitions.travel_distance_meters.

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

Specifies a map from visitTypes strings to durations. The duration is time in addition to VisitRequest.duration to be taken at visits with the specified visitTypes. This extra visit duration adds cost if costPerHour is specified. Keys (i.e. visitTypes) cannot be empty strings.

If a visit request has multiple types, a duration will be added for each type in the map.

object (BreakRule)

Describes the break schedule to be enforced on this vehicle. If empty, no breaks will be scheduled for this vehicle.

string

Specifies a label for this vehicle. This label is reported in the response as the vehicleLabel of the corresponding ShipmentRoute.

boolean

If true, usedIfRouteIsEmpty must be false, and this vehicle will remain unused.

If a shipment is performed by an ignored vehicle in injectedFirstSolutionRoutes, it is skipped in the first solution but is free to be performed in the response.

If a shipment is performed by an ignored vehicle in injectedSolutionConstraint and any related pickup/delivery is constrained to remain on the vehicle (i.e., not relaxed to level RELAX_ALL_AFTER_THRESHOLD), it is skipped in the response. If a shipment has a non-empty allowedVehicleIndices field and all of the allowed vehicles are ignored, it is skipped in the response.

number

Specifies a multiplicative factor that can be used to increase or decrease travel times of this vehicle. For example, setting this to 2.0 means that this vehicle is slower and has travel times that are twice what they are for standard vehicles. This multiple does not affect visit durations. It does affect cost if costPerHour or costPerTraveledHour are specified. This must be in the range [0.001, 1000.0]. If unset, the vehicle is standard, and this multiple is considered 1.0.

WARNING: Travel times will be rounded to the nearest second after this multiple is applied but before performing any numerical operations, thus, a small multiple may result in a loss of precision.

See also extraVisitDurationForVisitType below.

{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}

boolean

Specifies whether to avoid toll roads where reasonable. Preference will be given to routes not containing toll roads. Applies only to motorized travel modes.

boolean

Specifies whether to avoid highways where reasonable. Preference will be given to routes not containing highways. Applies only to motorized travel modes.

boolean

Specifies whether to avoid ferries where reasonable. Preference will be given to routes not containing travel by ferries. Applies only to motorized travel modes.

boolean

Optional. Specifies whether to avoid navigating indoors where reasonable. Preference will be given to routes not containing indoor navigation. Applies only to the WALKING travel mode.

{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string
}

string (int64 format)

A soft limit of the load. See costPerUnitAboveSoftMax.

number

If the load ever exceeds softMaxLoad along this vehicle's route, the following cost penalty applies (only once per vehicle): (load - softMaxLoad) * costPerUnitAboveSoftMax. All costs add up and must be in the same unit as Shipment.penalty_cost.

object (Interval)

The acceptable load interval of the vehicle at the start of the route.

object (Interval)

The acceptable load interval of the vehicle at the end of the route.

string (int64 format)

The maximum acceptable amount of load.

{
  "min": string,
  "max": string
}

string (int64 format)

A minimum acceptable load. Must be ≥ 0. If they're both specified, min must be ≤ max.

string (int64 format)

A maximum acceptable load. Must be ≥ 0. If unspecified, the maximum load is unrestricted by this message. If they're both specified, min must be ≤ max.

{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}

string (Duration format)

A hard limit constraining the duration to be at most maxDuration.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

string (Duration format)

A soft limit not enforcing a maximum duration limit, but when violated makes the route incur a cost. This cost adds up to other costs defined in the model, with the same unit.

If defined, softMaxDuration must be nonnegative. If maxDuration is also defined, softMaxDuration must be less than maxDuration.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

string (Duration format)

A soft limit not enforcing a maximum duration limit, but when violated makes the route incur a cost, quadratic in the duration. This cost adds up to other costs defined in the model, with the same unit.

If defined, quadraticSoftMaxDuration must be nonnegative. If maxDuration is also defined, quadraticSoftMaxDuration must be less than maxDuration, and the difference must be no larger than one day:

maxDuration - quadraticSoftMaxDuration <= 86400 seconds

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

number

Cost per hour incurred if the softMaxDuration threshold is violated. The additional cost is 0 if the duration is under the threshold, otherwise the cost depends on the duration as follows:

  costPerHourAfterSoftMax * (duration - softMaxDuration)

The cost must be nonnegative.

number

Cost per square hour incurred if the quadraticSoftMaxDuration threshold is violated.

The additional cost is 0 if the duration is under the threshold, otherwise the cost depends on the duration as follows:

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

The cost must be nonnegative.

{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}

string (int64 format)

A hard limit constraining the distance to be at most maxMeters. The limit must be nonnegative.

string (int64 format)

A soft limit not enforcing a maximum distance limit, but when violated results in a cost which adds up to other costs defined in the model, with the same unit.

If defined softMaxMeters must be less than maxMeters and must be nonnegative.

number

Cost per kilometer incurred, increasing up to softMaxMeters, with formula:

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

This cost is not supported in routeDistanceLimit.

number

Cost per kilometer incurred if distance is above softMaxMeters limit. The additional cost is 0 if the distance is under the limit, otherwise the formula used to compute the cost is the following:

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

The cost must be nonnegative.

{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}

object (BreakRequest)

Sequence of breaks. See the BreakRequest message.

object (FrequencyConstraint)

Several FrequencyConstraint may apply. They must all be satisfied by the BreakRequests of this BreakRule. See FrequencyConstraint.

{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}

string (Timestamp format)

Required. Lower bound (inclusive) on the start of the break.

A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

string (Timestamp format)

Required. Upper bound (inclusive) on the start of the break.

A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

string (Duration format)

Required. Minimum duration of the break. Must be positive.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

{
  "minBreakDuration": string,
  "maxInterBreakDuration": string
}

string (Duration format)

Required. Minimum break duration for this constraint. Nonnegative. See description of FrequencyConstraint.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

string (Duration format)

Required. Maximum allowed span of any interval of time in the route that does not include at least partially a break of duration >= minBreakDuration. Must be positive.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}

object (Row)

Specifies the rows of the duration and distance matrix. It must have as many elements as ShipmentModel.duration_distance_matrix_src_tags.

string

Tag defining to which vehicles this duration and distance matrix applies. If empty, this applies to all vehicles, and there can only be a single matrix.

Each vehicle start must match exactly one matrix, i.e. exactly one of their startTags field must match the vehicleStartTag of a matrix (and of that matrix only).

All matrices must have a different vehicleStartTag.

{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}

string (Duration format)

Duration values for a given row. It must have as many elements as ShipmentModel.duration_distance_matrix_dst_tags.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

number

Distance values for a given row. If no costs or constraints refer to distances in the model, this can be left empty; otherwise it must have as many elements as durations.

{
  "srcTag": string,
  "excludedSrcTag": string,
  "dstTag": string,
  "excludedDstTag": string,
  "cost": number,
  "costPerKilometer": number,
  "distanceLimit": {
    object (DistanceLimit)
  },
  "delay": string
}

string

Tags defining the set of (src->dst) transitions these attributes apply to.

A source visit or vehicle start matches iff its VisitRequest.tags or Vehicle.start_tags either contains srcTag or does not contain excludedSrcTag (depending on which of these two fields is non-empty).

string

See srcTag. Exactly one of srcTag and excludedSrcTag must be non-empty.

string

A destination visit or vehicle end matches iff its VisitRequest.tags or Vehicle.end_tags either contains dstTag or does not contain excludedDstTag (depending on which of these two fields is non-empty).

string

See dstTag. Exactly one of dstTag and excludedDstTag must be non-empty.

number

Specifies a cost for performing this transition. This is in the same unit as all other costs in the model and must not be negative. It is applied on top of all other existing costs.

number

Specifies a cost per kilometer applied to the distance traveled while performing this transition. It adds up to any Vehicle.cost_per_kilometer specified on vehicles.

object (DistanceLimit)

Specifies a limit on the distance traveled while performing this transition.

As of 2021/06, only soft limits are supported.

string (Duration format)

Specifies a delay incurred when performing this transition.

This delay always occurs after finishing the source visit and before starting the destination visit.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}

string

List of incompatible types. Two shipments having different shipment_types among those listed are "incompatible".

enum (IncompatibilityMode)

Mode applied to the incompatibility.

{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}

string

List of alternative shipment types required by the dependentShipmentTypes.

string

All shipments with a type in the dependentShipmentTypes field require at least one shipment of type requiredShipmentTypeAlternatives to be visited on the same route.

NOTE: Chains of requirements such that a shipmentType depends on itself are not allowed.

enum (RequirementMode)

Mode applied to the requirement.

{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}

boolean

Indicates if the "first" event is a delivery.

boolean

Indicates if the "second" event is a delivery.

string (Duration format)

The offset between the "first" and "second" event. It can be negative.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

integer

Shipment index of the "first" event. This field must be specified.

integer

Shipment index of the "second" event. This field must be specified.