optimizationpb

type AggregatedMetrics struct {

	// Number of shipments performed. Note that a pickup and delivery pair only
	// counts once.
	PerformedShipmentCount int32 `` /* 130-byte string literal not displayed */
	// Total travel duration for a route or a solution.
	TravelDuration *durationpb.Duration `protobuf:"bytes,2,opt,name=travel_duration,json=travelDuration,proto3" json:"travel_duration,omitempty"`
	// Total wait duration for a route or a solution.
	WaitDuration *durationpb.Duration `protobuf:"bytes,3,opt,name=wait_duration,json=waitDuration,proto3" json:"wait_duration,omitempty"`
	// Total delay duration for a route or a solution.
	DelayDuration *durationpb.Duration `protobuf:"bytes,4,opt,name=delay_duration,json=delayDuration,proto3" json:"delay_duration,omitempty"`
	// Total break duration for a route or a solution.
	BreakDuration *durationpb.Duration `protobuf:"bytes,5,opt,name=break_duration,json=breakDuration,proto3" json:"break_duration,omitempty"`
	// Total visit duration for a route or a solution.
	VisitDuration *durationpb.Duration `protobuf:"bytes,6,opt,name=visit_duration,json=visitDuration,proto3" json:"visit_duration,omitempty"`
	// The total duration should be equal to the sum of all durations above.
	// For routes, it also corresponds to:
	// [ShipmentRoute.vehicle_end_time][google.cloud.optimization.v1.ShipmentRoute.vehicle_end_time]
	// `-`
	// [ShipmentRoute.vehicle_start_time][google.cloud.optimization.v1.ShipmentRoute.vehicle_start_time]
	TotalDuration *durationpb.Duration `protobuf:"bytes,7,opt,name=total_duration,json=totalDuration,proto3" json:"total_duration,omitempty"`
	// Total travel distance for a route or a solution.
	TravelDistanceMeters float64 `protobuf:"fixed64,8,opt,name=travel_distance_meters,json=travelDistanceMeters,proto3" json:"travel_distance_meters,omitempty"`
	// Maximum load achieved over the entire route (resp. solution), for each of
	// the quantities on this route (resp. solution), computed as the maximum over
	// all
	// [Transition.vehicle_loads][google.cloud.optimization.v1.ShipmentRoute.Transition.vehicle_loads]
	// (resp.
	// [ShipmentRoute.metrics.max_loads][google.cloud.optimization.v1.AggregatedMetrics.max_loads].
	MaxLoads map[string]*ShipmentRoute_VehicleLoad `` /* 173-byte string literal not displayed */
	// Deprecated: Use
	// [ShipmentRoute.route_costs][google.cloud.optimization.v1.ShipmentRoute.route_costs]
	// and
	// [OptimizeToursResponse.Metrics.costs][google.cloud.optimization.v1.OptimizeToursResponse.Metrics.costs]
	// instead.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	Costs map[string]float64 `` /* 154-byte string literal not displayed */
	// Deprecated: Use
	// [ShipmentRoute.route_total_cost][google.cloud.optimization.v1.ShipmentRoute.route_total_cost]
	// and
	// [OptimizeToursResponse.Metrics.total_cost][google.cloud.optimization.v1.OptimizeToursResponse.Metrics.total_cost]
	// instead.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	TotalCost float64 `protobuf:"fixed64,11,opt,name=total_cost,json=totalCost,proto3" json:"total_cost,omitempty"`
	// contains filtered or unexported fields
}

type AsyncModelMetadata struct {

	// The state of the current operation.
	State AsyncModelMetadata_State `protobuf:"varint,1,opt,name=state,proto3,enum=google.cloud.optimization.v1.AsyncModelMetadata_State" json:"state,omitempty"`
	// A message providing more details about the current state of the operation.
	// For example, the error message if the operation is failed.
	StateMessage string `protobuf:"bytes,2,opt,name=state_message,json=stateMessage,proto3" json:"state_message,omitempty"`
	// The creation time of the operation.
	CreateTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	// The last update time of the operation.
	UpdateTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
	// contains filtered or unexported fields
}

type AsyncModelMetadata_State int32

type BatchOptimizeToursRequest struct {

	// Required. Target project and location to make a call.
	//
	// Format: `projects/{project-id}/locations/{location-id}`.
	//
	// If no location is specified, a region will be chosen automatically.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Required. Input/Output information each purchase model, such as file paths
	// and data formats.
	ModelConfigs []*BatchOptimizeToursRequest_AsyncModelConfig `protobuf:"bytes,2,rep,name=model_configs,json=modelConfigs,proto3" json:"model_configs,omitempty"`
	// contains filtered or unexported fields
}

type BatchOptimizeToursRequest_AsyncModelConfig struct {

	// User defined model name, can be used as alias by users to keep track of
	// models.
	DisplayName string `protobuf:"bytes,1,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// Required. Information about the input model.
	InputConfig *InputConfig `protobuf:"bytes,2,opt,name=input_config,json=inputConfig,proto3" json:"input_config,omitempty"`
	// Required. The desired output location information.
	OutputConfig *OutputConfig `protobuf:"bytes,3,opt,name=output_config,json=outputConfig,proto3" json:"output_config,omitempty"`
	// If this is set, the model will be solved in the checkpoint mode. In this
	// mode, the input model can have a deadline longer than 30 mins without the
	// risk of interruption. The model will be solved in multiple short-running
	// stages. Each stage generates an intermediate checkpoint
	// and stores it in the user's Cloud Storage buckets. The checkpoint
	// mode should be preferred over
	// allow_large_deadline_despite_interruption_risk since it prevents the risk
	// of interruption.
	EnableCheckpoints bool `protobuf:"varint,4,opt,name=enable_checkpoints,json=enableCheckpoints,proto3" json:"enable_checkpoints,omitempty"`
	// contains filtered or unexported fields
}

type BatchOptimizeToursResponse struct {
	// contains filtered or unexported fields
}

type BreakRule struct {

	// Sequence of breaks. See the `BreakRequest` message.
	BreakRequests []*BreakRule_BreakRequest `protobuf:"bytes,1,rep,name=break_requests,json=breakRequests,proto3" json:"break_requests,omitempty"`
	// Several `FrequencyConstraint` may apply. They must all be satisfied by
	// the `BreakRequest`s of this `BreakRule`. See `FrequencyConstraint`.
	FrequencyConstraints []*BreakRule_FrequencyConstraint `protobuf:"bytes,2,rep,name=frequency_constraints,json=frequencyConstraints,proto3" json:"frequency_constraints,omitempty"`
	// contains filtered or unexported fields
}

type BreakRule_BreakRequest struct {

	// Required. Lower bound (inclusive) on the start of the break.
	EarliestStartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=earliest_start_time,json=earliestStartTime,proto3" json:"earliest_start_time,omitempty"`
	// Required. Upper bound (inclusive) on the start of the break.
	LatestStartTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=latest_start_time,json=latestStartTime,proto3" json:"latest_start_time,omitempty"`
	// Required. Minimum duration of the break. Must be positive.
	MinDuration *durationpb.Duration `protobuf:"bytes,3,opt,name=min_duration,json=minDuration,proto3" json:"min_duration,omitempty"`
	// contains filtered or unexported fields
}

type BreakRule_FrequencyConstraint struct {

	// Required. Minimum break duration for this constraint. Nonnegative.
	// See description of `FrequencyConstraint`.
	MinBreakDuration *durationpb.Duration `protobuf:"bytes,1,opt,name=min_break_duration,json=minBreakDuration,proto3" json:"min_break_duration,omitempty"`
	// Required. Maximum allowed span of any interval of time in the route that
	// does not include at least partially a break of `duration >=
	// min_break_duration`. Must be positive.
	MaxInterBreakDuration *durationpb.Duration `` /* 128-byte string literal not displayed */
	// contains filtered or unexported fields
}

type DataFormat int32

type DistanceLimit struct {

	// A hard limit constraining the distance to be at most max_meters. The limit
	// must be nonnegative.
	MaxMeters *int64 `protobuf:"varint,1,opt,name=max_meters,json=maxMeters,proto3,oneof" json:"max_meters,omitempty"`
	// 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 soft_max_meters must be less than max_meters and must be
	// nonnegative.
	SoftMaxMeters *int64 `protobuf:"varint,2,opt,name=soft_max_meters,json=softMaxMeters,proto3,oneof" json:"soft_max_meters,omitempty"`
	// Cost per kilometer incurred, increasing up to `soft_max_meters`, with
	// formula:
	// “`
	//
	//	min(distance_meters, soft_max_meters) / 1000.0 *
	//	cost_per_kilometer_below_soft_max.
	//
	// “`
	// This cost is not supported in `route_distance_limit`.
	CostPerKilometerBelowSoftMax *float64 `` /* 161-byte string literal not displayed */
	// Cost per kilometer incurred if distance is above `soft_max_meters` limit.
	// The additional cost is 0 if the distance is under the limit, otherwise the
	// formula used to compute the cost is the following:
	// “`
	//
	//	(distance_meters - soft_max_meters) / 1000.0 *
	//	cost_per_kilometer_above_soft_max.
	//
	// “`
	// The cost must be nonnegative.
	CostPerKilometerAboveSoftMax *float64 `` /* 161-byte string literal not displayed */
	// contains filtered or unexported fields
}

type FleetRoutingClient interface {
	// Sends an `OptimizeToursRequest` containing a `ShipmentModel` and returns an
	// `OptimizeToursResponse` containing `ShipmentRoute`s, which are a set of
	// routes to be performed by vehicles minimizing the overall cost.
	//
	// A `ShipmentModel` model consists mainly of `Shipment`s that need to be
	// carried out and `Vehicle`s that can be used to transport the `Shipment`s.
	// The `ShipmentRoute`s assign `Shipment`s to `Vehicle`s. More specifically,
	// they assign a series of `Visit`s to each vehicle, where a `Visit`
	// corresponds to a `VisitRequest`, which is a pickup or delivery for a
	// `Shipment`.
	//
	// The goal is to provide an assignment of `ShipmentRoute`s to `Vehicle`s that
	// minimizes the total cost where cost has many components defined in the
	// `ShipmentModel`.
	OptimizeTours(ctx context.Context, in *OptimizeToursRequest, opts ...grpc.CallOption) (*OptimizeToursResponse, error)
	// Optimizes vehicle tours for one or more `OptimizeToursRequest`
	// messages as a batch.
	//
	// This method is a Long Running Operation (LRO). The inputs for optimization
	// (`OptimizeToursRequest` messages) and outputs (`OptimizeToursResponse`
	// messages) are read/written from/to Cloud Storage in user-specified
	// format. Like the `OptimizeTours` method, each `OptimizeToursRequest`
	// contains a `ShipmentModel` and returns an `OptimizeToursResponse`
	// containing `ShipmentRoute`s, which are a set of routes to be performed by
	// vehicles minimizing the overall cost.
	BatchOptimizeTours(ctx context.Context, in *BatchOptimizeToursRequest, opts ...grpc.CallOption) (*longrunningpb.Operation, error)
}

type FleetRoutingServer interface {
	// Sends an `OptimizeToursRequest` containing a `ShipmentModel` and returns an
	// `OptimizeToursResponse` containing `ShipmentRoute`s, which are a set of
	// routes to be performed by vehicles minimizing the overall cost.
	//
	// A `ShipmentModel` model consists mainly of `Shipment`s that need to be
	// carried out and `Vehicle`s that can be used to transport the `Shipment`s.
	// The `ShipmentRoute`s assign `Shipment`s to `Vehicle`s. More specifically,
	// they assign a series of `Visit`s to each vehicle, where a `Visit`
	// corresponds to a `VisitRequest`, which is a pickup or delivery for a
	// `Shipment`.
	//
	// The goal is to provide an assignment of `ShipmentRoute`s to `Vehicle`s that
	// minimizes the total cost where cost has many components defined in the
	// `ShipmentModel`.
	OptimizeTours(context.Context, *OptimizeToursRequest) (*OptimizeToursResponse, error)
	// Optimizes vehicle tours for one or more `OptimizeToursRequest`
	// messages as a batch.
	//
	// This method is a Long Running Operation (LRO). The inputs for optimization
	// (`OptimizeToursRequest` messages) and outputs (`OptimizeToursResponse`
	// messages) are read/written from/to Cloud Storage in user-specified
	// format. Like the `OptimizeTours` method, each `OptimizeToursRequest`
	// contains a `ShipmentModel` and returns an `OptimizeToursResponse`
	// containing `ShipmentRoute`s, which are a set of routes to be performed by
	// vehicles minimizing the overall cost.
	BatchOptimizeTours(context.Context, *BatchOptimizeToursRequest) (*longrunningpb.Operation, error)
}

type GcsDestination struct {

	// Required. URI of the Google Cloud Storage location.
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	// contains filtered or unexported fields
}

type GcsSource struct {

	// Required. URI of the Google Cloud Storage location.
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	// contains filtered or unexported fields
}

type InjectedSolutionConstraint struct {

	// Routes of the solution to inject. Some routes may be omitted from the
	// original solution. The routes and skipped shipments must satisfy the basic
	// validity assumptions listed for `injected_first_solution_routes`.
	Routes []*ShipmentRoute `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
	// Skipped shipments of the solution to inject. Some may be omitted from the
	// original solution. See the `routes` field.
	SkippedShipments []*SkippedShipment `protobuf:"bytes,2,rep,name=skipped_shipments,json=skippedShipments,proto3" json:"skipped_shipments,omitempty"`
	// For zero or more groups of vehicles, specifies when and how much to relax
	// constraints. If this field is empty, all non-empty vehicle routes are
	// fully constrained.
	ConstraintRelaxations []*InjectedSolutionConstraint_ConstraintRelaxation `protobuf:"bytes,3,rep,name=constraint_relaxations,json=constraintRelaxations,proto3" json:"constraint_relaxations,omitempty"`
	// contains filtered or unexported fields
}

type InjectedSolutionConstraint_ConstraintRelaxation struct {

	// All the visit constraint relaxations that will apply to visits on
	// routes with vehicles in `vehicle_indices`.
	Relaxations []*InjectedSolutionConstraint_ConstraintRelaxation_Relaxation `protobuf:"bytes,1,rep,name=relaxations,proto3" json:"relaxations,omitempty"`
	// Specifies the vehicle indices to which the visit constraint
	// `relaxations` apply. If empty, this is considered the default and the
	// `relaxations` apply to all vehicles that are not specified in other
	// `constraint_relaxations`. There can be at most one default, i.e., at
	// most one constraint relaxation field is allowed empty
	// `vehicle_indices`. A vehicle index can only be listed once, even within
	// several `constraint_relaxations`.
	//
	// A vehicle index is mapped the same as
	// [ShipmentRoute.vehicle_index][google.cloud.optimization.v1.ShipmentRoute.vehicle_index],
	// if `interpret_injected_solutions_using_labels` is true (see `fields`
	// comment).
	VehicleIndices []int32 `protobuf:"varint,2,rep,packed,name=vehicle_indices,json=vehicleIndices,proto3" json:"vehicle_indices,omitempty"`
	// contains filtered or unexported fields
}

type InjectedSolutionConstraint_ConstraintRelaxation_Relaxation struct {

	// The constraint relaxation level that applies when the conditions
	// at or after `threshold_time` AND at least `threshold_visit_count` are
	// satisfied.
	Level InjectedSolutionConstraint_ConstraintRelaxation_Relaxation_Level `` /* 163-byte string literal not displayed */
	// The time at or after which the relaxation `level` may be applied.
	ThresholdTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=threshold_time,json=thresholdTime,proto3" json:"threshold_time,omitempty"`
	// The number of visits at or after which the relaxation `level` may be
	// applied. If `threshold_visit_count` is 0 (or unset), the `level` may be
	// applied directly at the vehicle start.
	//
	// If it is `route.visits_size() + 1`, the `level` may only be applied to
	// the vehicle end. If it is more than `route.visits_size() + 1`,
	// `level` is not applied at all for that route.
	ThresholdVisitCount int32 `protobuf:"varint,3,opt,name=threshold_visit_count,json=thresholdVisitCount,proto3" json:"threshold_visit_count,omitempty"`
	// contains filtered or unexported fields
}

type InjectedSolutionConstraint_ConstraintRelaxation_Relaxation_Level int32

type InputConfig struct {

	// The location of the input model in cloud storage.
	// Required.
	//
	// Types that are assignable to Source:
	//
	//	*InputConfig_GcsSource
	Source isInputConfig_Source `protobuf_oneof:"source"`
	// The input data format that used to store the model in Cloud Storage.
	DataFormat DataFormat `` /* 137-byte string literal not displayed */
	// contains filtered or unexported fields
}

type InputConfig_GcsSource struct {
	// The Google Cloud Storage location to read the input from. This must be a
	// single file.
	GcsSource *GcsSource `protobuf:"bytes,1,opt,name=gcs_source,json=gcsSource,proto3,oneof"`
}

type Location struct {

	// The waypoint's geographic coordinates.
	LatLng *latlng.LatLng `protobuf:"bytes,1,opt,name=lat_lng,json=latLng,proto3" json:"lat_lng,omitempty"`
	// 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.
	Heading *int32 `protobuf:"varint,2,opt,name=heading,proto3,oneof" json:"heading,omitempty"`
	// contains filtered or unexported fields
}

type OptimizeToursRequest struct {

	// Required. Target project and location to make a call.
	//
	// Format: `projects/{project-id}/locations/{location-id}`.
	//
	// If no location is specified, a region will be chosen automatically.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// If this timeout is set, the server returns a response before the timeout
	// period has elapsed or the server deadline for synchronous requests is
	// reached, whichever is sooner.
	//
	// For asynchronous requests, the server will generate a solution (if
	// possible) before the timeout has elapsed.
	Timeout *durationpb.Duration `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// Shipment model to solve.
	Model *ShipmentModel `protobuf:"bytes,3,opt,name=model,proto3" json:"model,omitempty"`
	// By default, the solving mode is `DEFAULT_SOLVE` (0).
	SolvingMode OptimizeToursRequest_SolvingMode `` /* 162-byte string literal not displayed */
	// Search mode used to solve the request.
	SearchMode OptimizeToursRequest_SearchMode `` /* 158-byte string literal not displayed */
	// Guide the optimization algorithm in finding a first solution that is
	// similar to a previous solution.
	//
	// The model is constrained when the first solution is built.
	// Any shipments not performed on a route are implicitly skipped in the first
	// solution, but they may be performed in successive solutions.
	//
	// The solution must satisfy some basic validity assumptions:
	//
	//   - for all routes, `vehicle_index` must be in range and not be duplicated.
	//   - for all visits, `shipment_index` and `visit_request_index` must be
	//     in range.
	//   - a shipment may only be referenced on one route.
	//   - the pickup of a pickup-delivery shipment must be performed before
	//     the delivery.
	//   - no more than one pickup alternative or delivery alternative of
	//     a shipment may be performed.
	//   - for all routes, times are increasing (i.e., `vehicle_start_time
	//     <= visits[0].start_time <= visits[1].start_time ...
	//     <= vehicle_end_time`).
	//   - a shipment may only be performed on a vehicle that is allowed. A
	//     vehicle is allowed if
	//     [Shipment.allowed_vehicle_indices][google.cloud.optimization.v1.Shipment.allowed_vehicle_indices]
	//     is empty or its `vehicle_index` is included in
	//     [Shipment.allowed_vehicle_indices][google.cloud.optimization.v1.Shipment.allowed_vehicle_indices].
	//
	// If the injected solution is not feasible, a validation error is not
	// necessarily returned and an error indicating infeasibility may be returned
	// instead.
	InjectedFirstSolutionRoutes []*ShipmentRoute `` /* 146-byte string literal not displayed */
	// Constrain the optimization algorithm to find a final solution that is
	// similar to a previous solution. For example, this may be used to freeze
	// portions of routes which have already been completed or which are to be
	// completed but must not be modified.
	//
	// If the injected solution is not feasible, a validation error is not
	// necessarily returned and an error indicating infeasibility may be returned
	// instead.
	InjectedSolutionConstraint *InjectedSolutionConstraint `` /* 141-byte string literal not displayed */
	// If non-empty, the given routes will be refreshed, without modifying their
	// underlying sequence of visits or travel times: only other details will be
	// updated. This does not solve the model.
	//
	// As of 2020/11, this only populates the polylines of non-empty routes and
	// requires that `populate_polylines` is true.
	//
	// The `route_polyline` fields of the passed-in routes may be inconsistent
	// with route `transitions`.
	//
	// This field must not be used together with `injected_first_solution_routes`
	// or `injected_solution_constraint`.
	//
	// `Shipment.ignore` and `Vehicle.ignore` have no effect on the behavior.
	// Polylines are still populated between all visits in all non-empty routes
	// regardless of whether the related shipments or vehicles are ignored.
	RefreshDetailsRoutes []*ShipmentRoute `protobuf:"bytes,9,rep,name=refresh_details_routes,json=refreshDetailsRoutes,proto3" json:"refresh_details_routes,omitempty"`
	// If true:
	//
	//   - uses
	//     [ShipmentRoute.vehicle_label][google.cloud.optimization.v1.ShipmentRoute.vehicle_label]
	//     instead of `vehicle_index` to
	//     match routes in an injected solution with vehicles in the request;
	//     reuses the mapping of original
	//     [ShipmentRoute.vehicle_index][google.cloud.optimization.v1.ShipmentRoute.vehicle_index]
	//     to new
	//     [ShipmentRoute.vehicle_index][google.cloud.optimization.v1.ShipmentRoute.vehicle_index]
	//     to update
	//     [ConstraintRelaxation.vehicle_indices][google.cloud.optimization.v1.InjectedSolutionConstraint.ConstraintRelaxation.vehicle_indices]
	//     if non-empty, but the mapping must be unambiguous (i.e., multiple
	//     `ShipmentRoute`s must not share the same original `vehicle_index`).
	//   - uses
	//     [ShipmentRoute.Visit.shipment_label][google.cloud.optimization.v1.ShipmentRoute.Visit.shipment_label]
	//     instead of `shipment_index`
	//     to match visits in an injected solution with shipments in the request;
	//   - uses
	//     [SkippedShipment.label][google.cloud.optimization.v1.SkippedShipment.label]
	//     instead of
	//     [SkippedShipment.index][google.cloud.optimization.v1.SkippedShipment.index]
	//     to
	//     match skipped shipments in the injected solution with request
	//     shipments.
	//
	// This interpretation applies to the `injected_first_solution_routes`,
	// `injected_solution_constraint`, and `refresh_details_routes` fields.
	// It can be used when shipment or vehicle indices in the request have
	// changed since the solution was created, perhaps because shipments or
	// vehicles have been removed from or added to the request.
	//
	// If true, labels in the following categories must appear at most once in
	// their category:
	//
	//   - [Vehicle.label][google.cloud.optimization.v1.Vehicle.label] in the
	//     request;
	//   - [Shipment.label][google.cloud.optimization.v1.Shipment.label] in the
	//     request;
	//   - [ShipmentRoute.vehicle_label][google.cloud.optimization.v1.ShipmentRoute.vehicle_label] in the injected solution;
	//   - [SkippedShipment.label][google.cloud.optimization.v1.SkippedShipment.label] and [ShipmentRoute.Visit.shipment_label][google.cloud.optimization.v1.ShipmentRoute.Visit.shipment_label] in
	//     the injected solution (except pickup/delivery visit pairs, whose
	//     `shipment_label` must appear twice).
	//
	// If a `vehicle_label` in the injected solution does not correspond to a
	// request vehicle, the corresponding route is removed from the solution
	// along with its visits. If a `shipment_label` in the injected solution does
	// not correspond to a request shipment, the corresponding visit is removed
	// from the solution. If a
	// [SkippedShipment.label][google.cloud.optimization.v1.SkippedShipment.label]
	// in the injected solution does not correspond to a request shipment, the
	// `SkippedShipment` is removed from the solution.
	//
	// Removing route visits or entire routes from an injected solution may
	// have an effect on the implied constraints, which may lead to change in
	// solution, validation errors, or infeasibility.
	//
	// NOTE: The caller must ensure that each
	// [Vehicle.label][google.cloud.optimization.v1.Vehicle.label] (resp.
	// [Shipment.label][google.cloud.optimization.v1.Shipment.label]) uniquely
	// identifies a vehicle (resp. shipment) entity used across the two relevant
	// requests: the past request that produced the `OptimizeToursResponse` used
	// in the injected solution and the current request that includes the injected
	// solution. The uniqueness checks described above are not enough to guarantee
	// this requirement.
	InterpretInjectedSolutionsUsingLabels bool `` /* 180-byte string literal not displayed */
	// Consider traffic estimation in calculating `ShipmentRoute` fields
	// [Transition.travel_duration][google.cloud.optimization.v1.ShipmentRoute.Transition.travel_duration],
	// [Visit.start_time][google.cloud.optimization.v1.ShipmentRoute.Visit.start_time],
	// and `vehicle_end_time`; in setting the
	// [ShipmentRoute.has_traffic_infeasibilities][google.cloud.optimization.v1.ShipmentRoute.has_traffic_infeasibilities]
	// field, and in calculating the
	// [OptimizeToursResponse.total_cost][google.cloud.optimization.v1.OptimizeToursResponse.total_cost]
	// field.
	ConsiderRoadTraffic bool `protobuf:"varint,11,opt,name=consider_road_traffic,json=considerRoadTraffic,proto3" json:"consider_road_traffic,omitempty"`
	// If true, polylines will be populated in response `ShipmentRoute`s.
	PopulatePolylines bool `protobuf:"varint,12,opt,name=populate_polylines,json=populatePolylines,proto3" json:"populate_polylines,omitempty"`
	// If true, polylines will be populated in response
	// [ShipmentRoute.transitions][google.cloud.optimization.v1.ShipmentRoute.transitions].
	// Note that in this case, the polylines will also be populated in the
	// deprecated `travel_steps`.
	PopulateTransitionPolylines bool `` /* 146-byte string literal not displayed */
	// If this is set, then the request can have a deadline
	// (see https://grpc.io/blog/deadlines) of up to 60 minutes.
	// Otherwise, the maximum deadline is only 30 minutes.
	// Note that long-lived requests have a significantly larger (but still small)
	// risk of interruption.
	AllowLargeDeadlineDespiteInterruptionRisk bool `` /* 194-byte string literal not displayed */
	// If true, travel distances will be computed using geodesic distances instead
	// of Google Maps distances, and travel times will be computed using geodesic
	// distances with a speed defined by `geodesic_meters_per_second`.
	UseGeodesicDistances bool `protobuf:"varint,15,opt,name=use_geodesic_distances,json=useGeodesicDistances,proto3" json:"use_geodesic_distances,omitempty"`
	// When `use_geodesic_distances` is true, this field must be set and defines
	// the speed applied to compute travel times. Its value must be at least 1.0
	// meters/seconds.
	GeodesicMetersPerSecond *float64 `` /* 143-byte string literal not displayed */
	// Truncates the number of validation errors returned. These errors are
	// typically attached to an INVALID_ARGUMENT error payload as a BadRequest
	// error detail (https://cloud.google.com/apis/design/errors#error_details),
	// unless solving_mode=VALIDATE_ONLY: see the
	// [OptimizeToursResponse.validation_errors][google.cloud.optimization.v1.OptimizeToursResponse.validation_errors]
	// field.
	// This defaults to 100 and is capped at 10,000.
	MaxValidationErrors *int32 `` /* 127-byte string literal not displayed */
	// Label that may be used to identify this request, reported back in the
	// [OptimizeToursResponse.request_label][google.cloud.optimization.v1.OptimizeToursResponse.request_label].
	Label string `protobuf:"bytes,17,opt,name=label,proto3" json:"label,omitempty"`
	// Deprecated: Use
	// [OptimizeToursRequest.populate_transition_polylines][google.cloud.optimization.v1.OptimizeToursRequest.populate_transition_polylines]
	// instead. If true, polylines will be populated in response
	// [ShipmentRoute.transitions][google.cloud.optimization.v1.ShipmentRoute.transitions].
	// Note that in this case, the polylines will also be populated in the
	// deprecated `travel_steps`.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	PopulateTravelStepPolylines bool `` /* 148-byte string literal not displayed */
	// contains filtered or unexported fields
}

type OptimizeToursRequest_SearchMode int32

type OptimizeToursRequest_SolvingMode int32

type OptimizeToursResponse struct {

	// Routes computed for each vehicle; the i-th route corresponds to the i-th
	// vehicle in the model.
	Routes []*ShipmentRoute `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
	// Copy of the
	// [OptimizeToursRequest.label][google.cloud.optimization.v1.OptimizeToursRequest.label],
	// if a label was specified in the request.
	RequestLabel string `protobuf:"bytes,3,opt,name=request_label,json=requestLabel,proto3" json:"request_label,omitempty"`
	// The list of all shipments skipped.
	SkippedShipments []*SkippedShipment `protobuf:"bytes,4,rep,name=skipped_shipments,json=skippedShipments,proto3" json:"skipped_shipments,omitempty"`
	// List of all the validation errors that we were able to detect
	// independently. See the "MULTIPLE ERRORS" explanation for the
	// [OptimizeToursValidationError][google.cloud.optimization.v1.OptimizeToursValidationError]
	// message.
	ValidationErrors []*OptimizeToursValidationError `protobuf:"bytes,5,rep,name=validation_errors,json=validationErrors,proto3" json:"validation_errors,omitempty"`
	// Duration, distance and usage metrics for this solution.
	Metrics *OptimizeToursResponse_Metrics `protobuf:"bytes,6,opt,name=metrics,proto3" json:"metrics,omitempty"`
	// Deprecated: Use
	// [Metrics.total_cost][google.cloud.optimization.v1.OptimizeToursResponse.Metrics.total_cost]
	// instead. Total cost of the solution. This takes into account all costs:
	// costs per per hour and travel hour, fixed vehicle costs, unperformed
	// shipment penalty costs, global duration cost, etc.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	TotalCost float64 `protobuf:"fixed64,2,opt,name=total_cost,json=totalCost,proto3" json:"total_cost,omitempty"`
	// contains filtered or unexported fields
}

type OptimizeToursResponse_Metrics struct {

	// Aggregated over the routes. Each metric is the sum (or max, for loads)
	// over all
	// [ShipmentRoute.metrics][google.cloud.optimization.v1.ShipmentRoute.metrics]
	// fields of the same name.
	AggregatedRouteMetrics *AggregatedMetrics `` /* 129-byte string literal not displayed */
	// Number of mandatory shipments skipped.
	SkippedMandatoryShipmentCount int32 `` /* 153-byte string literal not displayed */
	// Number of vehicles used. Note: if a vehicle route is empty and
	// [Vehicle.used_if_route_is_empty][google.cloud.optimization.v1.Vehicle.used_if_route_is_empty]
	// is true, the vehicle is considered used.
	UsedVehicleCount int32 `protobuf:"varint,3,opt,name=used_vehicle_count,json=usedVehicleCount,proto3" json:"used_vehicle_count,omitempty"`
	// The earliest start time for a used vehicle, computed as the minimum over
	// all used vehicles of
	// [ShipmentRoute.vehicle_start_time][google.cloud.optimization.v1.ShipmentRoute.vehicle_start_time].
	EarliestVehicleStartTime *timestamppb.Timestamp `` /* 137-byte string literal not displayed */
	// The latest end time for a used vehicle, computed as the maximum over all
	// used vehicles of
	// [ShipmentRoute.vehicle_end_time][google.cloud.optimization.v1.ShipmentRoute.vehicle_end_time].
	LatestVehicleEndTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=latest_vehicle_end_time,json=latestVehicleEndTime,proto3" json:"latest_vehicle_end_time,omitempty"`
	// Cost of the solution, broken down by cost-related request fields.
	// The keys are proto paths, relative to the input OptimizeToursRequest,
	// e.g. "model.shipments.pickups.cost", and the values are the total cost
	// generated by the corresponding cost field, aggregated over the whole
	// solution. In other words, costs["model.shipments.pickups.cost"] is the
	// sum of all pickup costs over the solution. All costs defined in the model
	// are reported in detail here with the exception of costs related to
	// TransitionAttributes that are only reported in an aggregated way as of
	// 2022/01.
	Costs map[string]float64 `` /* 154-byte string literal not displayed */
	// Total cost of the solution. The sum of all values in the costs map.
	TotalCost float64 `protobuf:"fixed64,6,opt,name=total_cost,json=totalCost,proto3" json:"total_cost,omitempty"`
	// contains filtered or unexported fields
}

type OptimizeToursValidationError struct {

	// A validation error is defined by the pair (`code`, `display_name`) which
	// are always present.
	//
	// Other fields (below) provide more context about the error.
	//
	// *MULTIPLE ERRORS*:
	// When there are multiple errors, the validation process tries to output
	// several of them. Much like a compiler, this is an imperfect process. Some
	// validation errors will be "fatal", meaning that they stop the entire
	// validation process. This is the case for `display_name="UNSPECIFIED"`
	// errors, among others. Some may cause the validation process to skip other
	// errors.
	//
	// *STABILITY*:
	// `code` and `display_name` should be very stable. But new codes and
	// display names may appear over time, which may cause a given (invalid)
	// request to yield a different (`code`, `display_name`) pair because the new
	// error hid the old one (see "MULTIPLE ERRORS").
	//
	// *REFERENCE*: A list of all (code, name) pairs:
	//
	// * UNSPECIFIED = 0;
	// * VALIDATION_TIMEOUT_ERROR = 10; Validation couldn't be completed within
	// the deadline.
	//
	// * REQUEST_OPTIONS_ERROR = 12;
	//   - REQUEST_OPTIONS_INVALID_SOLVING_MODE = 1201;
	//   - REQUEST_OPTIONS_INVALID_MAX_VALIDATION_ERRORS = 1203;
	//   - REQUEST_OPTIONS_INVALID_GEODESIC_METERS_PER_SECOND = 1204;
	//   - REQUEST_OPTIONS_GEODESIC_METERS_PER_SECOND_TOO_SMALL = 1205;
	//   - REQUEST_OPTIONS_MISSING_GEODESIC_METERS_PER_SECOND = 1206;
	//   - REQUEST_OPTIONS_POPULATE_PATHFINDER_TRIPS_AND_GEODESIC_DISTANCE
	//     = 1207;
	//   - REQUEST_OPTIONS_COST_MODEL_OPTIONS_AND_GEODESIC_DISTANCE = 1208;
	//   - REQUEST_OPTIONS_TRAVEL_MODE_INCOMPATIBLE_WITH_TRAFFIC = 1211;
	//   - REQUEST_OPTIONS_MULTIPLE_TRAFFIC_FLAVORS = 1212;
	//   - REQUEST_OPTIONS_INVALID_TRAFFIC_FLAVOR = 1213;
	//   - REQUEST_OPTIONS_TRAFFIC_ENABLED_WITHOUT_GLOBAL_START_TIME = 1214;
	//   - REQUEST_OPTIONS_TRAFFIC_ENABLED_WITH_PRECEDENCES = 1215;
	//   - REQUEST_OPTIONS_TRAFFIC_PREFILL_MODE_INVALID = 1216;
	//   - REQUEST_OPTIONS_TRAFFIC_PREFILL_ENABLED_WITHOUT_TRAFFIC = 1217;
	//
	// * INJECTED_SOLUTION_ERROR = 20;
	//   - INJECTED_SOLUTION_MISSING_LABEL = 2000;
	//   - INJECTED_SOLUTION_DUPLICATE_LABEL = 2001;
	//   - INJECTED_SOLUTION_AMBIGUOUS_INDEX = 2002;
	//   - INJECTED_SOLUTION_INFEASIBLE_AFTER_GETTING_TRAVEL_TIMES = 2003;
	//   - INJECTED_SOLUTION_TRANSITION_INCONSISTENT_WITH_ACTUAL_TRAVEL = 2004;
	//   - INJECTED_SOLUTION_CONCURRENT_SOLUTION_TYPES = 2005;
	//   - INJECTED_SOLUTION_MORE_THAN_ONE_PER_TYPE = 2006;
	//   - INJECTED_SOLUTION_REFRESH_WITHOUT_POPULATE = 2008;
	//   - INJECTED_SOLUTION_CONSTRAINED_ROUTE_PORTION_INFEASIBLE = 2010;
	//
	// * SHIPMENT_MODEL_ERROR = 22;
	//   - SHIPMENT_MODEL_TOO_LARGE = 2200;
	//   - SHIPMENT_MODEL_TOO_MANY_CAPACITY_TYPES = 2201;
	//   - SHIPMENT_MODEL_GLOBAL_START_TIME_NEGATIVE_OR_NAN = 2202;
	//   - SHIPMENT_MODEL_GLOBAL_END_TIME_TOO_LARGE_OR_NAN = 2203;
	//   - SHIPMENT_MODEL_GLOBAL_START_TIME_AFTER_GLOBAL_END_TIME = 2204;
	//   - SHIPMENT_MODEL_GLOBAL_DURATION_TOO_LONG = 2205;
	//   - SHIPMENT_MODEL_MAX_ACTIVE_VEHICLES_NOT_POSITIVE = 2206;
	//   - SHIPMENT_MODEL_DURATION_MATRIX_TOO_LARGE = 2207;
	//
	// * INDEX_ERROR = 24;
	// * TAG_ERROR = 26;
	// * TIME_WINDOW_ERROR = 28;
	//   - TIME_WINDOW_INVALID_START_TIME = 2800;
	//   - TIME_WINDOW_INVALID_END_TIME = 2801;
	//   - TIME_WINDOW_INVALID_SOFT_START_TIME = 2802;
	//   - TIME_WINDOW_INVALID_SOFT_END_TIME = 2803;
	//   - TIME_WINDOW_OUTSIDE_GLOBAL_TIME_WINDOW = 2804;
	//   - TIME_WINDOW_START_TIME_AFTER_END_TIME = 2805;
	//   - TIME_WINDOW_INVALID_COST_PER_HOUR_BEFORE_SOFT_START_TIME = 2806;
	//   - TIME_WINDOW_INVALID_COST_PER_HOUR_AFTER_SOFT_END_TIME = 2807;
	//   - TIME_WINDOW_COST_BEFORE_SOFT_START_TIME_WITHOUT_SOFT_START_TIME
	//     = 2808;
	//   - TIME_WINDOW_COST_AFTER_SOFT_END_TIME_WITHOUT_SOFT_END_TIME = 2809;
	//   - TIME_WINDOW_SOFT_START_TIME_WITHOUT_COST_BEFORE_SOFT_START_TIME
	//     = 2810;
	//   - TIME_WINDOW_SOFT_END_TIME_WITHOUT_COST_AFTER_SOFT_END_TIME = 2811;
	//   - TIME_WINDOW_OVERLAPPING_ADJACENT_OR_EARLIER_THAN_PREVIOUS = 2812;
	//   - TIME_WINDOW_START_TIME_AFTER_SOFT_START_TIME = 2813;
	//   - TIME_WINDOW_SOFT_START_TIME_AFTER_END_TIME = 2814;
	//   - TIME_WINDOW_START_TIME_AFTER_SOFT_END_TIME = 2815;
	//   - TIME_WINDOW_SOFT_END_TIME_AFTER_END_TIME = 2816;
	//   - TIME_WINDOW_COST_BEFORE_SOFT_START_TIME_SET_AND_MULTIPLE_WINDOWS
	//     = 2817;
	//   - TIME_WINDOW_COST_AFTER_SOFT_END_TIME_SET_AND_MULTIPLE_WINDOWS = 2818;
	//   - TRANSITION_ATTRIBUTES_ERROR = 30;
	//   - TRANSITION_ATTRIBUTES_INVALID_COST = 3000;
	//   - TRANSITION_ATTRIBUTES_INVALID_COST_PER_KILOMETER = 3001;
	//   - TRANSITION_ATTRIBUTES_DUPLICATE_TAG_PAIR = 3002;
	//   - TRANSITION_ATTRIBUTES_DISTANCE_LIMIT_MAX_METERS_UNSUPPORTED = 3003;
	//   - TRANSITION_ATTRIBUTES_UNSPECIFIED_SOURCE_TAGS = 3004;
	//   - TRANSITION_ATTRIBUTES_CONFLICTING_SOURCE_TAGS_FIELDS = 3005;
	//   - TRANSITION_ATTRIBUTES_UNSPECIFIED_DESTINATION_TAGS = 3006;
	//   - TRANSITION_ATTRIBUTES_CONFLICTING_DESTINATION_TAGS_FIELDS = 3007;
	//   - TRANSITION_ATTRIBUTES_DELAY_DURATION_NEGATIVE_OR_NAN = 3008;
	//   - TRANSITION_ATTRIBUTES_DELAY_DURATION_EXCEEDS_GLOBAL_DURATION = 3009;
	//
	// * AMOUNT_ERROR = 31;
	//   - AMOUNT_NEGATIVE_VALUE = 3100;
	//
	// * LOAD_LIMIT_ERROR = 33;
	//   - LOAD_LIMIT_INVALID_COST_ABOVE_SOFT_MAX = 3303;
	//   - LOAD_LIMIT_SOFT_MAX_WITHOUT_COST_ABOVE_SOFT_MAX = 3304;
	//   - LOAD_LIMIT_COST_ABOVE_SOFT_MAX_WITHOUT_SOFT_MAX = 3305;
	//   - LOAD_LIMIT_NEGATIVE_SOFT_MAX = 3306;
	//   - LOAD_LIMIT_MIXED_DEMAND_TYPE = 3307;
	//   - LOAD_LIMIT_MAX_LOAD_NEGATIVE_VALUE = 3308;
	//   - LOAD_LIMIT_SOFT_MAX_ABOVE_MAX = 3309;
	//
	// * INTERVAL_ERROR = 34;
	//   - INTERVAL_MIN_EXCEEDS_MAX = 3401;
	//   - INTERVAL_NEGATIVE_MIN = 3402;
	//   - INTERVAL_NEGATIVE_MAX = 3403;
	//   - INTERVAL_MIN_EXCEEDS_CAPACITY = 3404;
	//   - INTERVAL_MAX_EXCEEDS_CAPACITY = 3405;
	//
	// * DISTANCE_LIMIT_ERROR = 36;
	//   - DISTANCE_LIMIT_INVALID_COST_AFTER_SOFT_MAX = 3601;
	//   - DISTANCE_LIMIT_SOFT_MAX_WITHOUT_COST_AFTER_SOFT_MAX = 3602;
	//   - DISTANCE_LIMIT_COST_AFTER_SOFT_MAX_WITHOUT_SOFT_MAX = 3603;
	//   - DISTANCE_LIMIT_NEGATIVE_MAX = 3604;
	//   - DISTANCE_LIMIT_NEGATIVE_SOFT_MAX = 3605;
	//   - DISTANCE_LIMIT_SOFT_MAX_LARGER_THAN_MAX = 3606;
	//
	// * DURATION_LIMIT_ERROR = 38;
	//   - DURATION_LIMIT_MAX_DURATION_NEGATIVE_OR_NAN = 3800;
	//   - DURATION_LIMIT_SOFT_MAX_DURATION_NEGATIVE_OR_NAN = 3801;
	//   - DURATION_LIMIT_INVALID_COST_PER_HOUR_AFTER_SOFT_MAX = 3802;
	//   - DURATION_LIMIT_SOFT_MAX_WITHOUT_COST_AFTER_SOFT_MAX = 3803;
	//   - DURATION_LIMIT_COST_AFTER_SOFT_MAX_WITHOUT_SOFT_MAX = 3804;
	//   - DURATION_LIMIT_QUADRATIC_SOFT_MAX_DURATION_NEGATIVE_OR_NAN = 3805;
	//   - DURATION_LIMIT_INVALID_COST_AFTER_QUADRATIC_SOFT_MAX = 3806;
	//   - DURATION_LIMIT_QUADRATIC_SOFT_MAX_WITHOUT_COST_PER_SQUARE_HOUR
	//     = 3807;
	//   - DURATION_LIMIT_COST_PER_SQUARE_HOUR_WITHOUT_QUADRATIC_SOFT_MAX
	//     = 3808;
	//   - DURATION_LIMIT_QUADRATIC_SOFT_MAX_WITHOUT_MAX = 3809;
	//   - DURATION_LIMIT_SOFT_MAX_LARGER_THAN_MAX = 3810;
	//   - DURATION_LIMIT_QUADRATIC_SOFT_MAX_LARGER_THAN_MAX = 3811;
	//   - DURATION_LIMIT_DIFF_BETWEEN_MAX_AND_QUADRATIC_SOFT_MAX_TOO_LARGE
	//     = 3812;
	//   - DURATION_LIMIT_MAX_DURATION_EXCEEDS_GLOBAL_DURATION = 3813;
	//   - DURATION_LIMIT_SOFT_MAX_DURATION_EXCEEDS_GLOBAL_DURATION = 3814;
	//   - DURATION_LIMIT_QUADRATIC_SOFT_MAX_DURATION_EXCEEDS_GLOBAL_DURATION
	//     = 3815;
	//
	// * SHIPMENT_ERROR = 40;
	//   - SHIPMENT_PD_LIMIT_WITHOUT_PICKUP_AND_DELIVERY = 4014;
	//   - SHIPMENT_PD_ABSOLUTE_DETOUR_LIMIT_DURATION_NEGATIVE_OR_NAN = 4000;
	//   - SHIPMENT_PD_ABSOLUTE_DETOUR_LIMIT_DURATION_EXCEEDS_GLOBAL_DURATION
	//     = 4001;
	//   - SHIPMENT_PD_RELATIVE_DETOUR_LIMIT_INVALID = 4015;
	//   - SHIPMENT_PD_DETOUR_LIMIT_AND_EXTRA_VISIT_DURATION = 4016;
	//   - SHIPMENT_PD_TIME_LIMIT_DURATION_NEGATIVE_OR_NAN = 4002;
	//   - SHIPMENT_PD_TIME_LIMIT_DURATION_EXCEEDS_GLOBAL_DURATION = 4003;
	//   - SHIPMENT_EMPTY_SHIPMENT_TYPE = 4004;
	//   - SHIPMENT_NO_PICKUP_NO_DELIVERY = 4005;
	//   - SHIPMENT_INVALID_PENALTY_COST = 4006;
	//   - SHIPMENT_ALLOWED_VEHICLE_INDEX_OUT_OF_BOUNDS = 4007;
	//   - SHIPMENT_DUPLICATE_ALLOWED_VEHICLE_INDEX = 4008;
	//   - SHIPMENT_INCONSISTENT_COST_FOR_VEHICLE_SIZE_WITHOUT_INDEX = 4009;
	//   - SHIPMENT_INCONSISTENT_COST_FOR_VEHICLE_SIZE_WITH_INDEX = 4010;
	//   - SHIPMENT_INVALID_COST_FOR_VEHICLE = 4011;
	//   - SHIPMENT_COST_FOR_VEHICLE_INDEX_OUT_OF_BOUNDS = 4012;
	//   - SHIPMENT_DUPLICATE_COST_FOR_VEHICLE_INDEX = 4013;
	//
	// * VEHICLE_ERROR = 42;
	//   - VEHICLE_EMPTY_REQUIRED_OPERATOR_TYPE = 4200;
	//   - VEHICLE_DUPLICATE_REQUIRED_OPERATOR_TYPE = 4201;
	//   - VEHICLE_NO_OPERATOR_WITH_REQUIRED_OPERATOR_TYPE = 4202;
	//   - VEHICLE_EMPTY_START_TAG = 4203;
	//   - VEHICLE_DUPLICATE_START_TAG = 4204;
	//   - VEHICLE_EMPTY_END_TAG = 4205;
	//   - VEHICLE_DUPLICATE_END_TAG = 4206;
	//   - VEHICLE_EXTRA_VISIT_DURATION_NEGATIVE_OR_NAN = 4207;
	//   - VEHICLE_EXTRA_VISIT_DURATION_EXCEEDS_GLOBAL_DURATION = 4208;
	//   - VEHICLE_EXTRA_VISIT_DURATION_EMPTY_KEY = 4209;
	//   - VEHICLE_FIRST_SHIPMENT_INDEX_OUT_OF_BOUNDS = 4210;
	//   - VEHICLE_FIRST_SHIPMENT_IGNORED = 4211;
	//   - VEHICLE_FIRST_SHIPMENT_NOT_BOUND = 4212;
	//   - VEHICLE_LAST_SHIPMENT_INDEX_OUT_OF_BOUNDS = 4213;
	//   - VEHICLE_LAST_SHIPMENT_IGNORED = 4214;
	//   - VEHICLE_LAST_SHIPMENT_NOT_BOUND = 4215;
	//   - VEHICLE_IGNORED_WITH_USED_IF_ROUTE_IS_EMPTY = 4216;
	//   - VEHICLE_INVALID_COST_PER_KILOMETER = 4217;
	//   - VEHICLE_INVALID_COST_PER_HOUR = 4218;
	//   - VEHICLE_INVALID_COST_PER_TRAVELED_HOUR = 4219;
	//   - VEHICLE_INVALID_FIXED_COST = 4220;
	//   - VEHICLE_INVALID_TRAVEL_DURATION_MULTIPLE = 4221;
	//   - VEHICLE_TRAVEL_DURATION_MULTIPLE_WITH_SHIPMENT_PD_DETOUR_LIMITS
	//     = 4223;
	//   - VEHICLE_MATRIX_INDEX_WITH_SHIPMENT_PD_DETOUR_LIMITS = 4224;
	//   - VEHICLE_MINIMUM_DURATION_LONGER_THAN_DURATION_LIMIT = 4222;
	//
	// * VISIT_REQUEST_ERROR = 44;
	//   - VISIT_REQUEST_EMPTY_TAG = 4400;
	//   - VISIT_REQUEST_DUPLICATE_TAG = 4401;
	//   - VISIT_REQUEST_DURATION_NEGATIVE_OR_NAN = 4404;
	//   - VISIT_REQUEST_DURATION_EXCEEDS_GLOBAL_DURATION = 4405;
	//
	// * PRECEDENCE_ERROR = 46;
	//   - PRECEDENCE_RULE_MISSING_FIRST_INDEX = 4600;
	//   - PRECEDENCE_RULE_MISSING_SECOND_INDEX = 4601;
	//   - PRECEDENCE_RULE_FIRST_INDEX_OUT_OF_BOUNDS = 4602;
	//   - PRECEDENCE_RULE_SECOND_INDEX_OUT_OF_BOUNDS = 4603;
	//   - PRECEDENCE_RULE_DUPLICATE_INDEX = 4604;
	//   - PRECEDENCE_RULE_INEXISTENT_FIRST_VISIT_REQUEST = 4605;
	//   - PRECEDENCE_RULE_INEXISTENT_SECOND_VISIT_REQUEST = 4606;
	//
	// * BREAK_ERROR = 48;
	//   - BREAK_RULE_EMPTY = 4800;
	//   - BREAK_REQUEST_UNSPECIFIED_DURATION = 4801;
	//   - BREAK_REQUEST_UNSPECIFIED_EARLIEST_START_TIME = 4802;
	//   - BREAK_REQUEST_UNSPECIFIED_LATEST_START_TIME = 4803;
	//   - BREAK_REQUEST_DURATION_NEGATIVE_OR_NAN = 4804; = 4804;
	//   - BREAK_REQUEST_LATEST_START_TIME_BEFORE_EARLIEST_START_TIME = 4805;
	//   - BREAK_REQUEST_EARLIEST_START_TIME_BEFORE_GLOBAL_START_TIME = 4806;
	//   - BREAK_REQUEST_LATEST_END_TIME_AFTER_GLOBAL_END_TIME = 4807;
	//   - BREAK_REQUEST_NON_SCHEDULABLE = 4808;
	//   - BREAK_FREQUENCY_MAX_INTER_BREAK_DURATION_NEGATIVE_OR_NAN = 4809;
	//   - BREAK_FREQUENCY_MIN_BREAK_DURATION_NEGATIVE_OR_NAN = 4810;
	//   - BREAK_FREQUENCY_MIN_BREAK_DURATION_EXCEEDS_GLOBAL_DURATION = 4811;
	//   - BREAK_FREQUENCY_MAX_INTER_BREAK_DURATION_EXCEEDS_GLOBAL_DURATION
	//     = 4812;
	//   - BREAK_REQUEST_DURATION_EXCEEDS_GLOBAL_DURATION = 4813;
	//   - BREAK_FREQUENCY_MISSING_MAX_INTER_BREAK_DURATION = 4814;
	//   - BREAK_FREQUENCY_MISSING_MIN_BREAK_DURATION = 4815;
	//
	// * SHIPMENT_TYPE_INCOMPATIBILITY_ERROR = 50;
	//   - SHIPMENT_TYPE_INCOMPATIBILITY_EMPTY_TYPE = 5001;
	//   - SHIPMENT_TYPE_INCOMPATIBILITY_LESS_THAN_TWO_TYPES = 5002;
	//   - SHIPMENT_TYPE_INCOMPATIBILITY_DUPLICATE_TYPE = 5003;
	//   - SHIPMENT_TYPE_INCOMPATIBILITY_INVALID_INCOMPATIBILITY_MODE = 5004;
	//   - SHIPMENT_TYPE_INCOMPATIBILITY_TOO_MANY_INCOMPATIBILITIES = 5005;
	//
	// * SHIPMENT_TYPE_REQUIREMENT_ERROR = 52;
	//   - SHIPMENT_TYPE_REQUIREMENT_NO_REQUIRED_TYPE = 52001;
	//   - SHIPMENT_TYPE_REQUIREMENT_NO_DEPENDENT_TYPE = 52002;
	//   - SHIPMENT_TYPE_REQUIREMENT_INVALID_REQUIREMENT_MODE = 52003;
	//   - SHIPMENT_TYPE_REQUIREMENT_TOO_MANY_REQUIREMENTS = 52004;
	//   - SHIPMENT_TYPE_REQUIREMENT_EMPTY_REQUIRED_TYPE = 52005;
	//   - SHIPMENT_TYPE_REQUIREMENT_DUPLICATE_REQUIRED_TYPE = 52006;
	//   - SHIPMENT_TYPE_REQUIREMENT_NO_REQUIRED_TYPE_FOUND = 52007;
	//   - SHIPMENT_TYPE_REQUIREMENT_EMPTY_DEPENDENT_TYPE = 52008;
	//   - SHIPMENT_TYPE_REQUIREMENT_DUPLICATE_DEPENDENT_TYPE = 52009;
	//   - SHIPMENT_TYPE_REQUIREMENT_SELF_DEPENDENT_TYPE = 52010;
	//   - SHIPMENT_TYPE_REQUIREMENT_GRAPH_HAS_CYCLES = 52011;
	//
	// * VEHICLE_OPERATOR_ERROR = 54;
	//   - VEHICLE_OPERATOR_EMPTY_TYPE = 5400;
	//   - VEHICLE_OPERATOR_MULTIPLE_START_TIME_WINDOWS = 5401;
	//   - VEHICLE_OPERATOR_SOFT_START_TIME_WINDOW = 5402;
	//   - VEHICLE_OPERATOR_MULTIPLE_END_TIME_WINDOWS = 5403;
	//   - VEHICLE_OPERATOR_SOFT_END_TIME_WINDOW = 5404;
	//
	// * DURATION_SECONDS_MATRIX_ERROR = 56;
	//   - DURATION_SECONDS_MATRIX_DURATION_NEGATIVE_OR_NAN = 5600;
	//   - DURATION_SECONDS_MATRIX_DURATION_EXCEEDS_GLOBAL_DURATION = 5601;
	Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	// The error display name.
	DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// An error context may involve 0, 1 (most of the time) or more fields. For
	// example, referring to vehicle #4 and shipment #2's first pickup can be
	// done as follows:
	// “`
	// fields { name: "vehicles" index: 4}
	// fields { name: "shipments" index: 2 sub_field {name: "pickups" index: 0} }
	// “`
	// Note, however, that the cardinality of `fields` should not change for a
	// given error code.
	Fields []*OptimizeToursValidationError_FieldReference `protobuf:"bytes,3,rep,name=fields,proto3" json:"fields,omitempty"`
	// Human-readable string describing the error. There is a 1:1 mapping
	// between `code` and `error_message` (when code != "UNSPECIFIED").
	//
	// *STABILITY*: Not stable: the error message associated to a given `code` may
	// change (hopefully to clarify it) over time. Please rely on the
	// `display_name` and `code` instead.
	ErrorMessage string `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// May contain the value(s) of the field(s). This is not always available. You
	// should absolutely not rely on it and use it only for manual model
	// debugging.
	OffendingValues string `protobuf:"bytes,5,opt,name=offending_values,json=offendingValues,proto3" json:"offending_values,omitempty"`
	// contains filtered or unexported fields
}

type OptimizeToursValidationError_FieldReference struct {

	// Name of the field, e.g., "vehicles".
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are assignable to IndexOrKey:
	//
	//	*OptimizeToursValidationError_FieldReference_Index
	//	*OptimizeToursValidationError_FieldReference_Key
	IndexOrKey isOptimizeToursValidationError_FieldReference_IndexOrKey `protobuf_oneof:"index_or_key"`
	// Recursively nested sub-field, if needed.
	SubField *OptimizeToursValidationError_FieldReference `protobuf:"bytes,3,opt,name=sub_field,json=subField,proto3" json:"sub_field,omitempty"`
	// contains filtered or unexported fields
}

type OptimizeToursValidationError_FieldReference_Index struct {
	// Index of the field if repeated.
	Index int32 `protobuf:"varint,2,opt,name=index,proto3,oneof"`
}

type OptimizeToursValidationError_FieldReference_Key struct {
	// Key if the field is a map.
	Key string `protobuf:"bytes,4,opt,name=key,proto3,oneof"`
}

type OutputConfig struct {

	// The location of the output result in cloud storage.
	// Required.
	//
	// Types that are assignable to Destination:
	//
	//	*OutputConfig_GcsDestination
	Destination isOutputConfig_Destination `protobuf_oneof:"destination"`
	// The output data format that used to store the results in Cloud Storage.
	DataFormat DataFormat `` /* 137-byte string literal not displayed */
	// contains filtered or unexported fields
}

type OutputConfig_GcsDestination struct {
	// The Google Cloud Storage location to write the output to.
	GcsDestination *GcsDestination `protobuf:"bytes,1,opt,name=gcs_destination,json=gcsDestination,proto3,oneof"`
}

type RouteModifiers struct {

	// Specifies whether to avoid toll roads where reasonable. Preference will be
	// given to routes not containing toll roads. Applies only to motorized travel
	// modes.
	AvoidTolls bool `protobuf:"varint,2,opt,name=avoid_tolls,json=avoidTolls,proto3" json:"avoid_tolls,omitempty"`
	// Specifies whether to avoid highways where reasonable. Preference will be
	// given to routes not containing highways. Applies only to motorized travel
	// modes.
	AvoidHighways bool `protobuf:"varint,3,opt,name=avoid_highways,json=avoidHighways,proto3" json:"avoid_highways,omitempty"`
	// Specifies whether to avoid ferries where reasonable. Preference will be
	// given to routes not containing travel by ferries. Applies only to motorized
	// travel modes.
	AvoidFerries bool `protobuf:"varint,4,opt,name=avoid_ferries,json=avoidFerries,proto3" json:"avoid_ferries,omitempty"`
	// 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.
	AvoidIndoor bool `protobuf:"varint,5,opt,name=avoid_indoor,json=avoidIndoor,proto3" json:"avoid_indoor,omitempty"`
	// contains filtered or unexported fields
}

type Shipment struct {

	// Set of pickup alternatives associated to the shipment. If not specified,
	// the vehicle only needs to visit a location corresponding to the deliveries.
	Pickups []*Shipment_VisitRequest `protobuf:"bytes,1,rep,name=pickups,proto3" json:"pickups,omitempty"`
	// Set of delivery alternatives associated to the shipment. If not specified,
	// the vehicle only needs to visit a location corresponding to the pickups.
	Deliveries []*Shipment_VisitRequest `protobuf:"bytes,2,rep,name=deliveries,proto3" json:"deliveries,omitempty"`
	// 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.
	LoadDemands map[string]*Shipment_Load `` /* 183-byte string literal not displayed */
	// 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.
	PenaltyCost *float64 `protobuf:"fixed64,4,opt,name=penalty_cost,json=penaltyCost,proto3,oneof" json:"penalty_cost,omitempty"`
	// 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.
	AllowedVehicleIndices []int32 `` /* 134-byte string literal not displayed */
	// 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 `costs_per_vehicle_indices`.
	//     `costs_per_vehicle[i]` corresponds to vehicle
	//     `costs_per_vehicle_indices[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 `penalty_cost` and must not be
	// negative. Leave this field empty, if there are no such costs.
	CostsPerVehicle []float64 `protobuf:"fixed64,6,rep,packed,name=costs_per_vehicle,json=costsPerVehicle,proto3" json:"costs_per_vehicle,omitempty"`
	// Indices of the vehicles to which `costs_per_vehicle` applies. If non-empty,
	// it must have the same number of elements as `costs_per_vehicle`. A vehicle
	// index may not be specified more than once. If a vehicle is excluded from
	// `costs_per_vehicle_indices`, its cost is zero.
	CostsPerVehicleIndices []int32 `` /* 139-byte string literal not displayed */
	// 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 `pickup_to_delivery_relative_detour_limit` enforces:
	//
	// “`
	// start_time(delivery) - start_time(pickup) <=
	// std::ceil(t * (1.0 + pickup_to_delivery_relative_detour_limit))
	// “`
	//
	// 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.
	PickupToDeliveryRelativeDetourLimit *float64 `` /* 182-byte string literal not displayed */
	// 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 `pickup_to_delivery_absolute_detour_limit` enforces:
	//
	// “`
	// start_time(delivery) - start_time(pickup) <=
	// t + pickup_to_delivery_absolute_detour_limit
	// “`
	//
	// 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.
	PickupToDeliveryAbsoluteDetourLimit *durationpb.Duration `` /* 174-byte string literal not displayed */
	// 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.
	PickupToDeliveryTimeLimit *durationpb.Duration `` /* 143-byte string literal not displayed */
	// Non-empty string specifying a "type" for this shipment.
	// This feature can be used to define incompatibilities or requirements
	// between `shipment_types` (see `shipment_type_incompatibilities` and
	// `shipment_type_requirements` in `ShipmentModel`).
	//
	// Differs from `visit_types` which is specified for a single visit: All
	// pickup/deliveries belonging to the same shipment share the same
	// `shipment_type`.
	ShipmentType string `protobuf:"bytes,11,opt,name=shipment_type,json=shipmentType,proto3" json:"shipment_type,omitempty"`
	// Specifies a label for this shipment. This label is reported in the response
	// in the `shipment_label` of the corresponding
	// [ShipmentRoute.Visit][google.cloud.optimization.v1.ShipmentRoute.Visit].
	Label string `protobuf:"bytes,12,opt,name=label,proto3" json:"label,omitempty"`
	// If true, skip this shipment, but don't apply a `penalty_cost`.
	//
	// Ignoring a shipment results in a validation error when there are any
	// `shipment_type_requirements` in the model.
	//
	// Ignoring a shipment that is performed in `injected_first_solution_routes`
	// or `injected_solution_constraint` is permitted; the solver removes the
	// related pickup/delivery visits from the performing route.
	// `precedence_rules` that reference ignored shipments will also be ignored.
	Ignore bool `protobuf:"varint,13,opt,name=ignore,proto3" json:"ignore,omitempty"`
	// Deprecated: Use
	// [Shipment.load_demands][google.cloud.optimization.v1.Shipment.load_demands]
	// instead.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	Demands []*CapacityQuantity `protobuf:"bytes,3,rep,name=demands,proto3" json:"demands,omitempty"`
	// contains filtered or unexported fields
}

type ShipmentModel struct {

	// Set of shipments which must be performed in the model.
	Shipments []*Shipment `protobuf:"bytes,1,rep,name=shipments,proto3" json:"shipments,omitempty"`
	// Set of vehicles which can be used to perform visits.
	Vehicles []*Vehicle `protobuf:"bytes,2,rep,name=vehicles,proto3" json:"vehicles,omitempty"`
	// Constrains the maximum number of active vehicles. A vehicle is active if
	// its route performs at least one shipment. This can be used to limit the
	// number of routes in the case where there are fewer drivers than
	// vehicles and that the fleet of vehicles is heterogeneous. The optimization
	// will then select the best subset of vehicles to use.
	// Must be strictly positive.
	MaxActiveVehicles *int32 `protobuf:"varint,4,opt,name=max_active_vehicles,json=maxActiveVehicles,proto3,oneof" json:"max_active_vehicles,omitempty"`
	// Global start and end time of the model: no times outside of this range
	// can be considered valid.
	//
	// The model's time span must be less than a year, i.e. the `global_end_time`
	// and the `global_start_time` must be within 31536000 seconds of each other.
	//
	// When using `cost_per_*hour` fields, you might want to set this window to a
	// smaller interval to increase performance (eg. if you model a single day,
	// you should set the global time limits to that day).
	// If unset, 00:00:00 UTC, January 1, 1970 (i.e. seconds: 0, nanos: 0) is used
	// as default.
	GlobalStartTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=global_start_time,json=globalStartTime,proto3" json:"global_start_time,omitempty"`
	// If unset, 00:00:00 UTC, January 1, 1971 (i.e. seconds: 31536000, nanos: 0)
	// is used as default.
	GlobalEndTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=global_end_time,json=globalEndTime,proto3" json:"global_end_time,omitempty"`
	// The "global duration" of the overall plan is the difference between the
	// earliest effective start time and the latest effective end time of
	// all vehicles. Users can assign a cost per hour to that quantity to try
	// and optimize for earliest job completion, for example. This cost must be in
	// the same unit as
	// [Shipment.penalty_cost][google.cloud.optimization.v1.Shipment.penalty_cost].
	GlobalDurationCostPerHour float64 `` /* 144-byte string literal not displayed */
	// Specifies duration and distance matrices used in the model. If this field
	// is empty, Google Maps or geodesic distances will be used instead, depending
	// on the value of the `use_geodesic_distances` field. If it is not empty,
	// `use_geodesic_distances` cannot be true and neither
	// `duration_distance_matrix_src_tags` nor `duration_distance_matrix_dst_tags`
	// can be empty.
	//
	// Usage examples:
	//
	// * There are two locations: locA and locB.
	// * 1 vehicle starting its route at locA and ending it at locA.
	// * 1 pickup visit request at locB.
	//
	// “`
	//
	//	model {
	//	  vehicles { start_tags: "locA"  end_tags: "locA" }
	//	  shipments { pickups { tags: "locB" } }
	//	  duration_distance_matrix_src_tags: "locA"
	//	  duration_distance_matrix_src_tags: "locB"
	//	  duration_distance_matrix_dst_tags: "locA"
	//	  duration_distance_matrix_dst_tags: "locB"
	//	  duration_distance_matrices {
	//	    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
	//	    }
	//	  }
	//	}
	//
	// “`
	//
	//   - There are three locations: locA, locB and locC.
	//   - 1 vehicle starting its route at locA and ending it at locB, using
	//     matrix "fast".
	//   - 1 vehicle starting its route at locB and ending it at locB, using
	//     matrix "slow".
	//   - 1 vehicle starting its route at locB and ending it at locB, using
	//     matrix "fast".
	//   - 1 pickup visit request at locC.
	//
	// “`
	//
	//	model {
	//	  vehicles { start_tags: "locA" end_tags: "locB" start_tags: "fast" }
	//	  vehicles { start_tags: "locB" end_tags: "locB" start_tags: "slow" }
	//	  vehicles { start_tags: "locB" end_tags: "locB" start_tags: "fast" }
	//	  shipments { pickups { tags: "locC" } }
	//	  duration_distance_matrix_src_tags: "locA"
	//	  duration_distance_matrix_src_tags: "locB"
	//	  duration_distance_matrix_src_tags: "locC"
	//	  duration_distance_matrix_dst_tags: "locB"
	//	  duration_distance_matrix_dst_tags: "locC"
	//	  duration_distance_matrices {
	//	    vehicle_start_tag: "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
	//	    }
	//	  }
	//	  duration_distance_matrices {
	//	    vehicle_start_tag: "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
	//	    }
	//	  }
	//	}
	//
	// “`
	DurationDistanceMatrices []*ShipmentModel_DurationDistanceMatrix `` /* 135-byte string literal not displayed */
	// Tags defining the sources of the duration and distance matrices;
	// `duration_distance_matrices(i).rows(j)` defines durations and distances
	// from visits with tag `duration_distance_matrix_src_tags(j)` to other visits
	// in matrix i.
	//
	// Tags correspond to
	// [VisitRequest.tags][google.cloud.optimization.v1.Shipment.VisitRequest.tags]
	// or [Vehicle.start_tags][google.cloud.optimization.v1.Vehicle.start_tags].
	// A given `VisitRequest` or `Vehicle` must match exactly one tag in this
	// field. Note that a `Vehicle`'s source, destination and matrix tags may be
	// the same; similarly a `VisitRequest`'s source and destination tags may be
	// the same. All tags must be different and cannot be empty strings. If this
	// field is not empty, then `duration_distance_matrices` must not be empty.
	DurationDistanceMatrixSrcTags []string `` /* 154-byte string literal not displayed */
	// Tags defining the destinations of the duration and distance matrices;
	// `duration_distance_matrices(i).rows(j).durations(k)` (resp.
	// `duration_distance_matrices(i).rows(j).meters(k))` defines the duration
	// (resp. the distance) of the travel from visits with tag
	// `duration_distance_matrix_src_tags(j)` to visits with tag
	// `duration_distance_matrix_dst_tags(k)` in matrix i.
	//
	// Tags correspond to
	// [VisitRequest.tags][google.cloud.optimization.v1.Shipment.VisitRequest.tags]
	// or [Vehicle.start_tags][google.cloud.optimization.v1.Vehicle.start_tags].
	// A given `VisitRequest` or `Vehicle` must match exactly one tag in this
	// field. Note that a `Vehicle`'s source, destination and matrix tags may be
	// the same; similarly a `VisitRequest`'s source and destination tags may be
	// the same. All tags must be different and cannot be empty strings. If this
	// field is not empty, then `duration_distance_matrices` must not be empty.
	DurationDistanceMatrixDstTags []string `` /* 155-byte string literal not displayed */
	// Transition attributes added to the model.
	TransitionAttributes []*TransitionAttributes `protobuf:"bytes,11,rep,name=transition_attributes,json=transitionAttributes,proto3" json:"transition_attributes,omitempty"`
	// Sets of incompatible shipment_types (see `ShipmentTypeIncompatibility`).
	ShipmentTypeIncompatibilities []*ShipmentTypeIncompatibility `` /* 151-byte string literal not displayed */
	// Sets of `shipment_type` requirements (see `ShipmentTypeRequirement`).
	ShipmentTypeRequirements []*ShipmentTypeRequirement `` /* 136-byte string literal not displayed */
	// Set of precedence rules which must be enforced in the model.
	PrecedenceRules []*ShipmentModel_PrecedenceRule `protobuf:"bytes,14,rep,name=precedence_rules,json=precedenceRules,proto3" json:"precedence_rules,omitempty"`
	// Deprecated: No longer used.
	// Set of break rules used in the model.
	// Each vehicle specifies the `BreakRule` that applies to it via the
	// [Vehicle.break_rule_indices][google.cloud.optimization.v1.Vehicle.break_rule_indices]
	// field (which must be a singleton).
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	BreakRules []*ShipmentModel_BreakRule `protobuf:"bytes,15,rep,name=break_rules,json=breakRules,proto3" json:"break_rules,omitempty"`
	// contains filtered or unexported fields
}

type ShipmentModel_BreakRule_BreakRequest struct {

	// Required. Lower bound (inclusive) on the start of the break.
	EarliestStartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=earliest_start_time,json=earliestStartTime,proto3" json:"earliest_start_time,omitempty"`
	// Required. Upper bound (inclusive) on the start of the break.
	LatestStartTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=latest_start_time,json=latestStartTime,proto3" json:"latest_start_time,omitempty"`
	// Required. Minimum duration of the break. Must be positive.
	MinDuration *durationpb.Duration `protobuf:"bytes,3,opt,name=min_duration,json=minDuration,proto3" json:"min_duration,omitempty"`
	// contains filtered or unexported fields
}

type ShipmentModel_BreakRule_FrequencyConstraint struct {

	// Required. Minimum break duration for this constraint. Nonnegative.
	// See description of `FrequencyConstraint`.
	MinBreakDuration *durationpb.Duration `protobuf:"bytes,1,opt,name=min_break_duration,json=minBreakDuration,proto3" json:"min_break_duration,omitempty"`
	// Required. Maximum allowed span of any interval of time in the route
	// that does not include at least partially a break of `duration >=
	// min_break_duration`. Must be positive.
	MaxInterBreakDuration *durationpb.Duration `` /* 128-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ShipmentModel_DurationDistanceMatrix struct {

	// Specifies the rows of the duration and distance matrix. It must have as
	// many elements as
	// [ShipmentModel.duration_distance_matrix_src_tags][google.cloud.optimization.v1.ShipmentModel.duration_distance_matrix_src_tags].
	Rows []*ShipmentModel_DurationDistanceMatrix_Row `protobuf:"bytes,1,rep,name=rows,proto3" json:"rows,omitempty"`
	// 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 `start_tags` field must match the `vehicle_start_tag` of a matrix
	// (and of that matrix only).
	//
	// All matrices must have a different `vehicle_start_tag`.
	VehicleStartTag string `protobuf:"bytes,2,opt,name=vehicle_start_tag,json=vehicleStartTag,proto3" json:"vehicle_start_tag,omitempty"`
	// contains filtered or unexported fields
}

type ShipmentModel_DurationDistanceMatrix_Row struct {

	// Duration values for a given row. It must have as many elements as
	// [ShipmentModel.duration_distance_matrix_dst_tags][google.cloud.optimization.v1.ShipmentModel.duration_distance_matrix_dst_tags].
	Durations []*durationpb.Duration `protobuf:"bytes,1,rep,name=durations,proto3" json:"durations,omitempty"`
	// 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`.
	Meters []float64 `protobuf:"fixed64,2,rep,packed,name=meters,proto3" json:"meters,omitempty"`
	// contains filtered or unexported fields
}

type ShipmentModel_PrecedenceRule struct {

	// Shipment index of the "first" event. This field must be specified.
	FirstIndex *int32 `protobuf:"varint,1,opt,name=first_index,json=firstIndex,proto3,oneof" json:"first_index,omitempty"`
	// Indicates if the "first" event is a delivery.
	FirstIsDelivery bool `protobuf:"varint,3,opt,name=first_is_delivery,json=firstIsDelivery,proto3" json:"first_is_delivery,omitempty"`
	// Shipment index of the "second" event. This field must be specified.
	SecondIndex *int32 `protobuf:"varint,2,opt,name=second_index,json=secondIndex,proto3,oneof" json:"second_index,omitempty"`
	// Indicates if the "second" event is a delivery.
	SecondIsDelivery bool `protobuf:"varint,4,opt,name=second_is_delivery,json=secondIsDelivery,proto3" json:"second_is_delivery,omitempty"`
	// The offset between the "first" and "second" event. It can be negative.
	OffsetDuration *durationpb.Duration `protobuf:"bytes,5,opt,name=offset_duration,json=offsetDuration,proto3" json:"offset_duration,omitempty"`
	// contains filtered or unexported fields
}

type ShipmentRoute struct {

	// Vehicle performing the route, identified by its index in the source
	// `ShipmentModel`.
	VehicleIndex int32 `protobuf:"varint,1,opt,name=vehicle_index,json=vehicleIndex,proto3" json:"vehicle_index,omitempty"`
	// Label of the vehicle performing this route, equal to
	// `ShipmentModel.vehicles(vehicle_index).label`, if specified.
	VehicleLabel string `protobuf:"bytes,2,opt,name=vehicle_label,json=vehicleLabel,proto3" json:"vehicle_label,omitempty"`
	// Time at which the vehicle starts its route.
	VehicleStartTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=vehicle_start_time,json=vehicleStartTime,proto3" json:"vehicle_start_time,omitempty"`
	// Time at which the vehicle finishes its route.
	VehicleEndTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=vehicle_end_time,json=vehicleEndTime,proto3" json:"vehicle_end_time,omitempty"`
	// Ordered sequence of visits representing a route.
	// visits[i] is the i-th visit in the route.
	// If this field is empty, the vehicle is considered as unused.
	Visits []*ShipmentRoute_Visit `protobuf:"bytes,7,rep,name=visits,proto3" json:"visits,omitempty"`
	// Ordered list of transitions for the route.
	Transitions []*ShipmentRoute_Transition `protobuf:"bytes,8,rep,name=transitions,proto3" json:"transitions,omitempty"`
	// When
	// [OptimizeToursRequest.consider_road_traffic][google.cloud.optimization.v1.OptimizeToursRequest.consider_road_traffic],
	// is set to true, this field indicates that inconsistencies in route timings
	// are predicted using traffic-based travel duration estimates. There may be
	// insufficient time to complete traffic-adjusted travel, delays, and breaks
	// between visits, before the first visit, or after the last visit, while
	// still satisfying the visit and vehicle time windows. For example,
	//
	// “`
	//
	//	start_time(previous_visit) + duration(previous_visit) +
	//	travel_duration(previous_visit, next_visit) > start_time(next_visit)
	//
	// “`
	//
	// Arrival at next_visit will likely happen later than its current
	// time window due the increased estimate of travel time
	// `travel_duration(previous_visit, next_visit)` due to traffic. Also, a break
	// may be forced to overlap with a visit due to an increase in travel time
	// estimates and visit or break time window restrictions.
	HasTrafficInfeasibilities bool `` /* 139-byte string literal not displayed */
	// The encoded polyline representation of the route.
	// This field is only populated if
	// [OptimizeToursRequest.populate_polylines][google.cloud.optimization.v1.OptimizeToursRequest.populate_polylines]
	// is set to true.
	RoutePolyline *ShipmentRoute_EncodedPolyline `protobuf:"bytes,10,opt,name=route_polyline,json=routePolyline,proto3" json:"route_polyline,omitempty"`
	// Breaks scheduled for the vehicle performing this route.
	// The `breaks` sequence represents time intervals, each starting at the
	// corresponding `start_time` and lasting `duration` seconds.
	Breaks []*ShipmentRoute_Break `protobuf:"bytes,11,rep,name=breaks,proto3" json:"breaks,omitempty"`
	// Duration, distance and load metrics for this route. The fields of
	// [AggregatedMetrics][google.cloud.optimization.v1.AggregatedMetrics] are
	// summed over all
	// [ShipmentRoute.transitions][google.cloud.optimization.v1.ShipmentRoute.transitions]
	// or
	// [ShipmentRoute.visits][google.cloud.optimization.v1.ShipmentRoute.visits],
	// depending on the context.
	Metrics *AggregatedMetrics `protobuf:"bytes,12,opt,name=metrics,proto3" json:"metrics,omitempty"`
	// Cost of the route, broken down by cost-related request fields.
	// The keys are proto paths, relative to the input OptimizeToursRequest, e.g.
	// "model.shipments.pickups.cost", and the values are the total cost
	// generated by the corresponding cost field, aggregated over the whole route.
	// In other words, costs["model.shipments.pickups.cost"] is the sum of all
	// pickup costs over the route. All costs defined in the model are reported in
	// detail here with the exception of costs related to TransitionAttributes
	// that are only reported in an aggregated way as of 2022/01.
	RouteCosts map[string]float64 `` /* 182-byte string literal not displayed */
	// Total cost of the route. The sum of all costs in the cost map.
	RouteTotalCost float64 `protobuf:"fixed64,18,opt,name=route_total_cost,json=routeTotalCost,proto3" json:"route_total_cost,omitempty"`
	// Deprecated: Use
	// [Transition.vehicle_loads][google.cloud.optimization.v1.ShipmentRoute.Transition.vehicle_loads]
	// instead. Vehicle loads upon arrival at its end location, for each type
	// specified in
	// [Vehicle.capacities][google.cloud.optimization.v1.Vehicle.capacities],
	// `start_load_intervals`, `end_load_intervals` or demands. Exception: we omit
	// loads for quantity types unconstrained by intervals and that don't have any
	// non-zero demand on the route.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	EndLoads []*CapacityQuantity `protobuf:"bytes,13,rep,name=end_loads,json=endLoads,proto3" json:"end_loads,omitempty"`
	// Deprecated: Use
	// [ShipmentRoute.transitions][google.cloud.optimization.v1.ShipmentRoute.transitions]
	// instead. Ordered list of travel steps for the route.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	TravelSteps []*ShipmentRoute_TravelStep `protobuf:"bytes,14,rep,name=travel_steps,json=travelSteps,proto3" json:"travel_steps,omitempty"`
	// Deprecated: No longer used.
	// This field will only be populated at the
	// [ShipmentRoute.Visit][google.cloud.optimization.v1.ShipmentRoute.Visit]
	// level.
	//
	// This field is the extra detour time due to the shipments visited on the
	// route.
	//
	// It is equal to `vehicle_end_time` - `vehicle_start_time` - travel duration
	// from the vehicle's start_location to its `end_location`.
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	VehicleDetour *durationpb.Duration `protobuf:"bytes,15,opt,name=vehicle_detour,json=vehicleDetour,proto3" json:"vehicle_detour,omitempty"`
	// Deprecated: Delay occurring before the vehicle end. See
	// [TransitionAttributes.delay][google.cloud.optimization.v1.TransitionAttributes.delay].
	//
	// Deprecated: Marked as deprecated in google/cloud/optimization/v1/fleet_routing.proto.
	DelayBeforeVehicleEnd *ShipmentRoute_Delay `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ShipmentRoute_Break struct {

	// Start time of a break.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// Duration of a break.
	Duration *durationpb.Duration `protobuf:"bytes,2,opt,name=duration,proto3" json:"duration,omitempty"`
	// contains filtered or unexported fields
}