{
  "type": "object",
  "title": "UserTextContent",
  "required": [
    "type",
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "title": "Text",
      "maxLength": 204800,
      "description": "The text content."
    },
    "type": {
      "const": "text",
      "title": "Type",
      "description": "The type of the content part."
    }
  }
}

{
  "type": "object",
  "title": "ValidationError",
  "required": [
    "loc",
    "msg",
    "type"
  ],
  "properties": {
    "loc": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "string",
            "format": "bytes",
            "maxLength": 88
          },
          {
            "type": "integer",
            "format": "int32",
            "maximum": 1000,
            "minimum": 0
          }
        ]
      },
      "title": "Location",
      "maxItems": 10
    },
    "msg": {
      "type": "string",
      "title": "Message",
      "format": "bytes",
      "maxLength": 88,
      "description": "The error message."
    },
    "type": {
      "type": "string",
      "title": "Error Type",
      "format": "bytes",
      "maxLength": 88,
      "description": "Error type"
    }
  }
}

{
  "type": "object",
  "title": "VehicleData",
  "properties": {
    "type": {
      "type": "array",
      "items": {
        "enum": [
          "Depot",
          "Pickup",
          "Delivery",
          "Break",
          "w"
        ],
        "type": "string",
        "title": "LocationTypeEnum"
      },
      "title": "Type",
      "default": [],
      "description": "Type of routing point, whether it is Depot, Waypoint - w \nDelivery, Break, Pickup \n"
    },
    "route": {
      "type": "array",
      "items": {
        "type": "integer",
        "maximum": 2147483647,
        "minimum": 0
      },
      "title": "Route",
      "default": [],
      "description": "Route indices as per waypoint graph or cost matrix provided"
    },
    "task_id": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "Task Id",
      "default": [],
      "description": "task_ids being assigned to vehicle along with depot and breaks"
    },
    "arrival_stamp": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "title": "Arrival Stamp",
      "default": [],
      "description": "arrival stamps at each task locations"
    }
  }
}

{
  "type": "object",
  "title": "VehicleOrderMatch",
  "required": [
    "vehicle_id",
    "order_ids"
  ],
  "properties": {
    "order_ids": {
      "type": "array",
      "items": {
        "type": "integer"
      },
      "title": "Order Ids",
      "description": "dtype: int32, order_id >= 0. \n\n Indices of orders which can be served by this particular vehicle"
    },
    "vehicle_id": {
      "type": "integer",
      "title": "Vehicle Id",
      "maximum": 2147483647,
      "minimum": 0,
      "description": "dtype: int32, vehicle_id >= 0. \n\n Vehicle id as an integer, and can serve all the order listed in order_ids."
    }
  }
}

{
  "type": "object",
  "title": "VideoRequest",
  "required": [
    "image"
  ],
  "properties": {
    "seed": {
      "type": "integer",
      "title": "Seed",
      "default": 0,
      "minimum": 0,
      "description": "The seed which governs generation. Omit this option or use 0 for a random seed",
      "exclusiveMaximum": 4294967296
    },
    "image": {
      "type": "string",
      "title": "Image",
      "example": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAAEElEQVR4nGK6HcwNCAAA//8DTgE8HuxwEQAAAABJRU5ErkJggg==",
      "x-examples": [
        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAAEElEQVR4nGK6HcwNCAAA//8DTgE8HuxwEQAAAABJRU5ErkJggg==",
        "data:image/png;asset_id,5576911c-6031-47a4-8796-bb506b026ad0"
      ],
      "description": "A base64-encoded string of the initial image that will be scaled to 1024x576. Images should be in form of `data:image/{format};base64,{base64encodedimage}` if it's smaller than 200KB. Otherwise, it needs to be uploaded to a presigned S3 bucket using NVCF Asset APIs.Once uploaded you can refer to it using the following format: `data:image/png;asset_id,{asset_id}`.Accepted formats are `jpg`, `png` and `jpeg`."
    },
    "cfg_scale": {
      "type": "number",
      "title": "Cfg Scale",
      "default": 1.8,
      "maximum": 9,
      "description": "How strongly the video sticks to the original image. Use lower values to allow the model more freedom to make changes and higher values to correct motion distortions.",
      "exclusiveMinimum": 1
    },
    "motion_bucket_id": {
      "type": "integer",
      "title": "Motion Bucket Id",
      "default": 127,
      "maximum": 127,
      "minimum": 127,
      "description": "Controls how much motion to add/remove from the image. Only motion_bucket_id=127 is supported"
    }
  }
}

{
  "type": "object",
  "title": "VideoResponse",
  "required": [
    "video",
    "finish_reason",
    "seed"
  ],
  "properties": {
    "seed": {
      "type": "integer",
      "title": "Seed",
      "description": "The seed used during generation"
    },
    "video": {
      "type": "string",
      "title": "Video",
      "example": "/9j/4AAQSkZ...b+AVZ/9k=",
      "x-examples": [
        "/9j/4AAQSkZ...b+AVZ/9k="
      ],
      "description": "A base64-encoded string of the generated video (mp4)"
    },
    "finish_reason": {
      "$ref": "#/components/schemas/FinishReason"
    }
  },
  "x-konfig-properties": {
    "finish_reason": {
      "description": "The result of the generation process. `SUCCESS` indicates success. `ERROR` indicates an error. `CONTENT_FILTERED` indicates the result affected by the content filter"
    }
  }
}

{
  "type": "object",
  "title": "WaypointGraph",
  "required": [
    "edges",
    "offsets"
  ],
  "properties": {
    "edges": {
      "type": "array",
      "items": {
        "type": "integer",
        "maximum": 2147483647,
        "minimum": 0
      },
      "title": "Edges",
      "description": "dtype: int32, edge >= 0. \n\n Vertices of all the directed edges."
    },
    "offsets": {
      "type": "array",
      "items": {
        "type": "integer",
        "maximum": 2147483647,
        "minimum": 0
      },
      "title": "Offsets",
      "description": "dtype: int32, offset >= 0. \n\n Offsets which provide number of edges from the source vertex signified by the index."
    },
    "weights": {
      "type": "array",
      "items": {
        "type": "number",
        "minimum": 0
      },
      "title": "Weights",
      "nullable": true,
      "description": "dtype: float32, weight >= 0. \n\n Weights of each edges."
    }
  }
}

{
  "type": "object",
  "title": "Window",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "title": "Name",
      "pattern": "[A-Za-z\\s\\.]+",
      "maxLength": 40
    },
    "type": {
      "const": "Window",
      "title": "Type",
      "default": "Window"
    },
    "lat_max": {
      "type": "number",
      "title": "Lat Max",
      "default": 90
    },
    "lat_min": {
      "type": "number",
      "title": "Lat Min",
      "default": -90
    },
    "lon_max": {
      "type": "number",
      "title": "Lon Max",
      "default": 360
    },
    "lon_min": {
      "type": "number",
      "title": "Lon Min",
      "default": 0
    }
  },
  "description": "Window domain, specifies a lat/lon rectangle.\n\nParameters\n----------\nlat_min : float\n    Minimum latitude\nlon_min : float\n    Maximum longitude\nlon_min : float\n    Minimum longitude east\nlon_max : float\n    Maximum longitude east\ndiagnostics : List[Diagnostic]\n    List of diagnostics to be computed for this domain."
}

{
  "type": "object",
  "title": "cuoptData",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "object",
      "title": "OptimizedRoutingData",
      "nullable": true,
      "required": [
        "fleet_data",
        "task_data"
      ],
      "properties": {
        "task_data": {
          "allOf": [
            {
              "type": "object",
              "title": "TaskData",
              "required": [
                "task_locations"
              ],
              "properties": {
                "demand": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    }
                  },
                  "title": "Demand",
                  "example": [
                    [
                      1,
                      1
                    ],
                    [
                      3,
                      1
                    ]
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      [
                        1,
                        1
                      ],
                      [
                        3,
                        1
                      ]
                    ]
                  ],
                  "description": "dtype: int32 \n\n Note: For this release number of demand dimensions are limited to 3. \n\n Lists of demands of each tasks.\nMultiple demands can be added and each list represents one kind of demand. Order of these demands should match the type of vehicle capacities provided.Example: In case of two sets of demands per vehicle with 3 vehicles,  \n\n     [ \n\n         [dem_1_tsk_1, dem_1_tsk_2, dem_1_tsk_3], \n\n         [dem_2_tsk_1, dem_2_tsk_2, dem_2_tsk_3] \n\n     ]"
                },
                "prizes": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  },
                  "title": "Prizes",
                  "example": null,
                  "nullable": true,
                  "x-examples": [
                    null
                  ],
                  "description": "dtype: float32, prizes >= 0. \n\n List of values which signifies prizes that are collected for fulfilling each task. This can be used effectively in case solution is infeasible and need to drop few tasks to get feasible solution. Solver will prioritize for higher prize tasks "
                },
                "task_ids": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "title": "Task Ids",
                  "example": [
                    "Task-A",
                    "Task-B"
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      "Task-A",
                      "Task-B"
                    ]
                  ],
                  "description": "List of the task ids or names provided as a string."
                },
                "service_times": {
                  "anyOf": [
                    {
                      "type": "array",
                      "items": {
                        "type": "integer",
                        "maximum": 2147483647,
                        "minimum": 0
                      }
                    },
                    {
                      "type": "object",
                      "additionalProperties": {
                        "type": "array",
                        "items": {
                          "type": "integer"
                        }
                      }
                    }
                  ],
                  "title": "Service Times",
                  "example": [
                    0,
                    0
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      0,
                      0
                    ]
                  ],
                  "description": "dtype: int32, time >= 0. \n\n Service time for each task. Accepts a list of service times for all vehicles. In case of vehicle specific service times, accepts a dict with key as vehicle id and value as list of service times.Example schema: In case all vehicles have same service times,  \n\n     [tsk_1_srv_time, tsk_2_srv_time, tsk_3_srv_time] \n\n  \n\n In case, there are 2 types of vehicle types and each of them have different service times, \n\n     { \n\n         type-1: [tsk_1_srv_time, tsk_3_srv_time, tsk_3_srv_time], \n\n         type-2: [tsk_1_srv_time, tsk_3_srv_time, tsk_3_srv_time] \n\n     }"
                },
                "task_locations": {
                  "type": "array",
                  "items": {
                    "type": "integer",
                    "maximum": 2147483647,
                    "minimum": 0
                  },
                  "title": "Task Locations",
                  "example": [
                    1,
                    2
                  ],
                  "x-examples": [
                    [
                      1,
                      2
                    ]
                  ],
                  "description": "dtype: int32, location >= 0. \n\n Location where the task has been requested."
                },
                "task_time_windows": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    }
                  },
                  "title": "Task Time Windows",
                  "example": [
                    [
                      0,
                      5
                    ],
                    [
                      3,
                      9
                    ]
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      [
                        0,
                        5
                      ],
                      [
                        3,
                        9
                      ]
                    ]
                  ],
                  "description": "dtype: int32, time >= 0. \n\n Earliest and Latest time windows for each tasks.\nFor example the data would look as follows, \n \n\n     [ \n\n         [tsk_1_earliest, tsk_1_latest], \n\n         [tsk_2_earliest, tsk_2_latest] \n\n     ]"
                },
                "mandatory_task_ids": {
                  "type": "array",
                  "items": {
                    "type": "integer",
                    "maximum": 2147483647,
                    "minimum": 0
                  },
                  "title": "Mandatory Task Ids",
                  "example": null,
                  "nullable": true,
                  "x-examples": [
                    null
                  ],
                  "description": "dtype: int32, mandatory_task_id >= 0. \n\n Note: This is only effective when used along with drop infeasible option. \n\n A list of task ids which are mandatory and solver would fail if these cannot be fulfilled."
                },
                "order_vehicle_match": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "title": "OrderVehicleMatch",
                    "required": [
                      "order_id",
                      "vehicle_ids"
                    ],
                    "properties": {
                      "order_id": {
                        "type": "integer",
                        "title": "Order Id",
                        "maximum": 2147483647,
                        "minimum": 0,
                        "description": "dtype: int32, order_id >= 0. \n\n Indices of orders which can be served by this particular vehicleOrder id as an integer"
                      },
                      "vehicle_ids": {
                        "type": "array",
                        "items": {
                          "type": "integer",
                          "maximum": 2147483647,
                          "minimum": 0
                        },
                        "title": "Vehicle Ids",
                        "description": "dtype: int32, vehicle_id >= 0. \n\n Indices of the vehicles which can serve this particular order. \n"
                      }
                    }
                  },
                  "title": "Order Vehicle Match",
                  "example": [
                    {
                      "order_id": 0,
                      "vehicle_ids": [
                        0
                      ]
                    },
                    {
                      "order_id": 1,
                      "vehicle_ids": [
                        1
                      ]
                    }
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      {
                        "order_id": 0,
                        "vehicle_ids": [
                          0
                        ]
                      },
                      {
                        "order_id": 1,
                        "vehicle_ids": [
                          1
                        ]
                      }
                    ]
                  ],
                  "description": "A list of order vehicle match, where the match would contain a order id and a list of vehicle ids that can serve this order."
                },
                "pickup_and_delivery_pairs": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    }
                  },
                  "title": "Pickup And Delivery Pairs",
                  "example": null,
                  "nullable": true,
                  "x-examples": [
                    null
                  ],
                  "description": "dtype: int32, pairs >= 0. \n\n List of Pick-up and delivery index pairs from task locations.\nIn case we have the following pick-up and delivery locations, 2->1, 4->5, 3->4, then task locations would look something like, task_locations = [0, 2, 1, 4, 5, 3, 4] and pick-up and delivery pairs would be index of those locations in task location and would look like [[1, 2], [3, 4], [5, 6]], 1 is pickup index for location 2 and it should be delivered to location 1 which is at index 2.Example schema:  \n\n     [ \n\n         [pcikup_1_idx_to_task, drop_1_idx_to_task], \n\n         [pcikup_2_idx_to_task, drop_2_idx_to_task], \n\n     ]"
                }
              }
            }
          ],
          "description": "All Task information"
        },
        "fleet_data": {
          "allOf": [
            {
              "type": "object",
              "title": "FleetData",
              "required": [
                "vehicle_locations"
              ],
              "properties": {
                "capacities": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    }
                  },
                  "title": "Capacities",
                  "example": [
                    [
                      2,
                      2
                    ],
                    [
                      4,
                      1
                    ]
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      [
                        2,
                        2
                      ],
                      [
                        4,
                        1
                      ]
                    ]
                  ],
                  "description": "dtype: int32, capacity >= 0. \n\n Note: For this release number of capacity dimensions are limited to 3. \n\n Lists of capacities of each vehicle.\nMultiple capacities can be added and each list will represent one kind of capacity. Order of kind of the capacities should match order of the demands.\nTotal capacity for each type should be sufficient to complete all demand of that type.Example: In case of two sets of capacities per vehicle with 3 vehicles,  \n\n     [ \n\n         [cap_1_veh_1, cap_1_veh_2, cap_1_veh_3], \n\n         [cap_2_veh_1, cap_2_veh_2, cap_2_veh_3] \n\n     ]"
                },
                "priorities": {
                  "type": "array",
                  "items": {
                    "type": "integer",
                    "maximum": 255,
                    "minimum": 0
                  },
                  "title": "Priorities",
                  "example": [
                    0,
                    1
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      0,
                      1
                    ]
                  ],
                  "description": "dtype: int32 \n\n Priorities of each vehicle, lower the value higher the priority, value should be within [0, 255]"
                },
                "vehicle_ids": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "title": "Vehicle Ids",
                  "example": [
                    "veh-1",
                    "veh-2"
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      "veh-1",
                      "veh-2"
                    ]
                  ],
                  "description": "List of the vehicle ids or names provided as a string."
                },
                "min_vehicles": {
                  "type": "integer",
                  "title": "Min Vehicles",
                  "example": 2,
                  "maximum": 2147483647,
                  "minimum": 0,
                  "nullable": true,
                  "x-examples": [
                    2
                  ],
                  "description": "dtype: int32, min_vehicles >= 1. \n\n Solution should consider minimum number of vehicles"
                },
                "vehicle_types": {
                  "type": "array",
                  "items": {
                    "type": "integer",
                    "maximum": 255,
                    "minimum": 0
                  },
                  "title": "Vehicle Types",
                  "example": [
                    1,
                    2
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      1,
                      2
                    ]
                  ],
                  "description": "dtype: uint8. \n\n Types of vehicles in the fleet given as positive integers."
                },
                "skip_first_trips": {
                  "type": "array",
                  "items": {
                    "type": "boolean"
                  },
                  "title": "Skip First Trips",
                  "example": [
                    true,
                    false
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      true,
                      false
                    ]
                  ],
                  "description": "Drop the cost of trip to first location for that vehicle."
                },
                "drop_return_trips": {
                  "type": "array",
                  "items": {
                    "type": "boolean"
                  },
                  "title": "Drop Return Trips",
                  "example": [
                    true,
                    false
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      true,
                      false
                    ]
                  ],
                  "description": "Drop cost of return trip for each vehicle."
                },
                "vehicle_locations": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    }
                  },
                  "title": "Vehicle Locations",
                  "example": [
                    [
                      0,
                      0
                    ],
                    [
                      0,
                      0
                    ]
                  ],
                  "x-examples": [
                    [
                      [
                        0,
                        0
                      ],
                      [
                        0,
                        0
                      ]
                    ]
                  ],
                  "description": "dtype: int32, vehicle_location >= 0. \n\n Start and end location of the vehicles in the given set of locations in WayPointGraph or CostMatrices.\nExample: For 2 vehicles,  \n\n     [ \n\n         [veh_1_start_loc, veh_1_end_loc], \n\n         [veh_2_start_loc, veh_2_end_loc] \n\n     ]"
                },
                "vehicle_max_costs": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  },
                  "title": "Vehicle Max Costs",
                  "example": [
                    7,
                    10
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      7,
                      10
                    ]
                  ],
                  "description": "dtype: float32, max_costs >= 0. \n\n Maximum cost a vehicle can incur and it is based on cost matrix/cost waypoint graph."
                },
                "vehicle_max_times": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  },
                  "title": "Vehicle Max Times",
                  "example": [
                    7,
                    10
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      7,
                      10
                    ]
                  ],
                  "description": "dtype: float32, max_time >= 0. \n\n Maximum time a vehicle can operate (includes drive, service and wait time), this is based on travel time matrix/travel time waypoint graph."
                },
                "vehicle_fixed_costs": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  },
                  "title": "Vehicle Fixed Costs",
                  "example": [
                    15,
                    5
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      15,
                      5
                    ]
                  ],
                  "description": "dtype: float32, fixed_cost >= 0. \n\n Cost of each vehicle.This helps in routing where may be 2 vehicles with less cost is effective compared to 1 vehicle with huge cost. As example shows veh-0 (15) > veh-1 (5) + veh-2 (5)"
                },
                "vehicle_order_match": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "title": "VehicleOrderMatch",
                    "required": [
                      "vehicle_id",
                      "order_ids"
                    ],
                    "properties": {
                      "order_ids": {
                        "type": "array",
                        "items": {
                          "type": "integer",
                          "maximum": 2147483647,
                          "minimum": 0
                        },
                        "title": "Order Ids",
                        "description": "dtype: int32, order_id >= 0. \n\n Indices of orders which can be served by this particular vehicle"
                      },
                      "vehicle_id": {
                        "type": "integer",
                        "title": "Vehicle Id",
                        "maximum": 2147483647,
                        "minimum": 0,
                        "description": "dtype: int32, vehicle_id >= 0. \n\n Vehicle id as an integer, and can serve all the order listed in order_ids."
                      }
                    }
                  },
                  "title": "Vehicle Order Match",
                  "example": [
                    {
                      "order_ids": [
                        0
                      ],
                      "vehicle_id": 0
                    },
                    {
                      "order_ids": [
                        1
                      ],
                      "vehicle_id": 1
                    }
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      {
                        "order_ids": [
                          0
                        ],
                        "vehicle_id": 0
                      },
                      {
                        "order_ids": [
                          1
                        ],
                        "vehicle_id": 1
                      }
                    ]
                  ],
                  "description": "A list of vehicle order match, where the match would contain a vehicle id and a list of orders that vehicle can serve."
                },
                "vehicle_time_windows": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    }
                  },
                  "title": "Vehicle Time Windows",
                  "example": [
                    [
                      0,
                      10
                    ],
                    [
                      0,
                      10
                    ]
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      [
                        0,
                        10
                      ],
                      [
                        0,
                        10
                      ]
                    ]
                  ],
                  "description": "dtype: int32, time >= 0. \n\n Earliest and Latest time window pairs for each vehicle,\nfor example the data would look as follows for 2 vehicles, \n \n\n     [ \n\n         [veh_1_earliest, veh_1_latest], \n\n         [veh_2_earliest, veh_2_latest] \n\n     ]"
                },
                "vehicle_break_durations": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    }
                  },
                  "title": "Vehicle Break Durations",
                  "example": [
                    [
                      1,
                      1
                    ]
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      [
                        1,
                        1
                      ]
                    ]
                  ],
                  "description": "dtype: int32, time >= 0. \n\n Break duration for each vehicle. vehicle_break_time_windows should be provided to use this option.For example, in case of having 2 breaks for each vehicle,  \n\n     [ \n\n         [brk_1_veh_1_duration, brk_1_veh_2_duration], \n\n         [brk_2_veh_1_duration, brk_2_veh_2_duration], \n\n     ]"
                },
                "vehicle_break_locations": {
                  "type": "array",
                  "items": {
                    "type": "integer",
                    "maximum": 2147483647,
                    "minimum": 0
                  },
                  "title": "Vehicle Break Locations",
                  "example": [
                    0,
                    1
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      0,
                      1
                    ]
                  ],
                  "description": "dtype: int32, location >= 0. \n\n Break location where vehicles can take breaks. If not set, any location can be used for the break."
                },
                "vehicle_break_time_windows": {
                  "type": "array",
                  "items": {
                    "type": "array",
                    "items": {
                      "type": "array",
                      "items": {
                        "type": "integer",
                        "maximum": 2147483647,
                        "minimum": 0
                      }
                    }
                  },
                  "title": "Vehicle Break Time Windows",
                  "example": [
                    [
                      [
                        1,
                        2
                      ],
                      [
                        2,
                        3
                      ]
                    ]
                  ],
                  "nullable": true,
                  "x-examples": [
                    [
                      [
                        [
                          1,
                          2
                        ],
                        [
                          2,
                          3
                        ]
                      ]
                    ]
                  ],
                  "description": "dtype: int32, time >= 0. \n\n Multiple break time windows can be added for each vehicle.Earliest and Latest break time window pairs for each vehicle,\nFor example, in case of 2 sets of breaks for each vehicle which translates to 2 dimensions of breaks,\n \n\n     [ \n\n         [[brk_1_veh_1_earliest, brk_1_veh_1_latest], [brk_1_veh_2_earliest, brk_1_veh_2_latest]] \n\n         [[brk_2_veh_1_earliest, brk_2_veh_1_latest], [brk_2_veh_2_earliest, brk_2_veh_2_latest]] \n\n     ] \n\n The break duration within this time window is provided through vehicle_break_durations."
                }
              }
            }
          ],
          "description": "All Fleet information"
        },
        "solver_config": {
          "type": "object",
          "title": "UpdateSolverSettingsConfig",
          "nullable": true,
          "properties": {
            "objectives": {
              "type": "object",
              "title": "Objective",
              "nullable": true,
              "properties": {
                "cost": {
                  "type": "number",
                  "title": "Cost",
                  "example": 1,
                  "nullable": true,
                  "x-examples": [
                    1
                  ],
                  "description": "dtype: float32.  \n\n The weight assigned to minimizing the cost for a given solution, default value is 1"
                },
                "prize": {
                  "type": "number",
                  "title": "Prize",
                  "example": 0,
                  "nullable": true,
                  "x-examples": [
                    0
                  ],
                  "description": "dtype: float32. \n\n The weight assigned to the prize in accumulated prizes for each job fulfilled.This will be negated from overall values accumulated with other objectives.For example, if cost accumulated is 10 and objective value for it is 1, and if the prize accumulated is 3 and objective is 2, then total cost would look something like this 10 x 1 - 3 x 2 = 4."
                },
                "travel_time": {
                  "type": "number",
                  "title": "Travel Time",
                  "example": 0,
                  "nullable": true,
                  "x-examples": [
                    0
                  ],
                  "description": "dtype: float32. \n\n The weight assigned to minimizing total travel time for a given solution (includes drive, service and wait time)"
                },
                "vehicle_fixed_cost": {
                  "type": "number",
                  "title": "Vehicle Fixed Cost",
                  "example": 0,
                  "nullable": true,
                  "x-examples": [
                    0
                  ],
                  "description": "dtype: float32. \n\n The weight assigned to the accumulated fixed costs of each vehicle used in solution"
                },
                "variance_route_size": {
                  "type": "number",
                  "title": "Variance Route Size",
                  "example": 0,
                  "nullable": true,
                  "x-examples": [
                    0
                  ],
                  "description": "dtype: float32. \n\n The weight assigned to the variance in the number of orders served by each route."
                },
                "variance_route_service_time": {
                  "type": "number",
                  "title": "Variance Route Service Time",
                  "example": 0,
                  "nullable": true,
                  "x-examples": [
                    0
                  ],
                  "description": "dtype: float32. \n\n The weight assigned to the variance in the accumulated service times of each route"
                }
              },
              "description": "Values provided dictate the linear combination of factors used to evaluate solution quality.Only prize will be negated, all others gets accumulated. That's why sometime you might come across negative value as solution cost."
            },
            "time_limit": {
              "type": "number",
              "title": "Time Limit",
              "example": 1,
              "maximum": 2147483647,
              "minimum": 0,
              "nullable": true,
              "x-examples": [
                1
              ],
              "description": "SolverSettings time limit"
            },
            "config_file": {
              "type": "string",
              "title": "Config File",
              "example": null,
              "nullable": true,
              "x-examples": [
                null
              ],
              "description": "Dump configuration information in a given file as yaml"
            },
            "verbose_mode": {
              "type": "boolean",
              "title": "Verbose Mode",
              "default": false,
              "nullable": true,
              "description": "Displaying internal information during the solver execution."
            },
            "error_logging": {
              "type": "boolean",
              "title": "Error Logging",
              "default": true,
              "nullable": true,
              "description": "Displaying constraint error information during the solver execution."
            },
            "drop_infeasible_tasks": {
              "type": "boolean",
              "title": "Drop Infeasible Tasks",
              "default": false,
              "nullable": true,
              "description": "Note: Prize collection is recommend for finer control over  \n\n what tasks would be picked or dropped. Drops infeasible tasks and returns routes for only feasible tasks. This should be used when solver fails to find a solution to fulfill all the tasks/order, "
            }
          }
        },
        "cost_matrix_data": {
          "type": "object",
          "title": "UpdateCostMatrices",
          "default": {},
          "example": {
            "cost_matrix": {
              "1": [
                [
                  0,
                  1,
                  1
                ],
                [
                  1,
                  0,
                  1
                ],
                [
                  1,
                  1,
                  0
                ]
              ],
              "2": [
                [
                  0,
                  1,
                  1
                ],
                [
                  1,
                  0,
                  1
                ],
                [
                  1,
                  2,
                  0
                ]
              ]
            }
          },
          "nullable": true,
          "properties": {
            "data": {
              "type": "object",
              "title": "Data",
              "nullable": true,
              "description": "dtype : vehicle-type (uint8), cost (float32), cost >= 0.\n \n\n Sqaure matrix with cost to travel from A to B and B to A. \nIf there different types of vehicles which have different \ncost matrices, they can be provided with key value pair \nwhere key is vehicle-type and value is cost matrix. Value of \nvehicle type should be within [0, 255]",
              "additionalProperties": {
                "type": "array",
                "items": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  }
                }
              }
            },
            "cost_matrix": {
              "type": "object",
              "title": "Cost Matrix",
              "nullable": true,
              "deprecated": true,
              "description": "This field is deprecated, please use the 'data' field instead",
              "additionalProperties": {
                "type": "array",
                "items": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  }
                }
              }
            }
          },
          "x-examples": [
            {
              "cost_matrix": {
                "1": [
                  [
                    0,
                    1,
                    1
                  ],
                  [
                    1,
                    0,
                    1
                  ],
                  [
                    1,
                    1,
                    0
                  ]
                ],
                "2": [
                  [
                    0,
                    1,
                    1
                  ],
                  [
                    1,
                    0,
                    1
                  ],
                  [
                    1,
                    2,
                    0
                  ]
                ]
              }
            }
          ],
          "description": "Sqaure matrix with cost to travel from A to B and B to A. \nIf there are different types of vehicles which have different \ncost matrices, they can be provided with key value pair \nwhere key is vehicle-type and value is cost matrix. Value of \nvehicle type should be within [0, 255]"
        },
        "travel_time_matrix_data": {
          "type": "object",
          "title": "UpdateCostMatrices",
          "default": {},
          "example": {
            "cost_matrix": {
              "1": [
                [
                  0,
                  1,
                  1
                ],
                [
                  1,
                  0,
                  1
                ],
                [
                  1,
                  1,
                  0
                ]
              ],
              "2": [
                [
                  0,
                  1,
                  1
                ],
                [
                  1,
                  0,
                  1
                ],
                [
                  1,
                  2,
                  0
                ]
              ]
            }
          },
          "nullable": true,
          "properties": {
            "data": {
              "type": "object",
              "title": "Data",
              "nullable": true,
              "description": "dtype : vehicle-type (uint8), cost (float32), cost >= 0.\n \n\n Sqaure matrix with cost to travel from A to B and B to A. \nIf there different types of vehicles which have different \ncost matrices, they can be provided with key value pair \nwhere key is vehicle-type and value is cost matrix. Value of \nvehicle type should be within [0, 255]",
              "additionalProperties": {
                "type": "array",
                "items": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  }
                }
              }
            },
            "cost_matrix": {
              "type": "object",
              "title": "Cost Matrix",
              "nullable": true,
              "deprecated": true,
              "description": "This field is deprecated, please use the 'data' field instead",
              "additionalProperties": {
                "type": "array",
                "items": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "minimum": 0
                  }
                }
              }
            }
          },
          "x-examples": [
            {
              "cost_matrix": {
                "1": [
                  [
                    0,
                    1,
                    1
                  ],
                  [
                    1,
                    0,
                    1
                  ],
                  [
                    1,
                    1,
                    0
                  ]
                ],
                "2": [
                  [
                    0,
                    1,
                    1
                  ],
                  [
                    1,
                    0,
                    1
                  ],
                  [
                    1,
                    2,
                    0
                  ]
                ]
              }
            }
          ],
          "description": "Sqaure matrix with time to travel from A to B and B to A. \nIf there are different types of vehicles which have different \ntravel time matrices, they can be provided with key value pair \nwhere key is vehicle-type and value is time matrix. Value of \nvehicle type should be within [0, 255]"
        },
        "cost_waypoint_graph_data": {
          "type": "object",
          "title": "UpdateWaypointGraphData",
          "default": {},
          "example": null,
          "nullable": true,
          "properties": {
            "waypoint_graph": {
              "type": "object",
              "title": "Waypoint Graph",
              "nullable": true,
              "additionalProperties": {
                "type": "object",
                "title": "WaypointGraph",
                "required": [
                  "edges",
                  "offsets"
                ],
                "properties": {
                  "edges": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    },
                    "title": "Edges",
                    "description": "dtype: int32, edge >= 0. \n\n Vertices of all the directed edges."
                  },
                  "offsets": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    },
                    "title": "Offsets",
                    "description": "dtype: int32, offset >= 0. \n\n Offsets which provide number of edges from the source vertex signified by the index."
                  },
                  "weights": {
                    "type": "array",
                    "items": {
                      "type": "number",
                      "minimum": 0
                    },
                    "title": "Weights",
                    "nullable": true,
                    "description": "dtype: float32, weight >= 0. \n\n Weights of each edges."
                  }
                }
              }
            }
          },
          "x-examples": [
            null
          ],
          "description": "Waypoint graph with weights as cost to travel from A to B \nand B to A. If there are different types of vehicles \nthey can be provided with key value pair \nwhere key is vehicle-type and value is the graph. Value of \nvehicle type should be within [0, 255]"
        },
        "travel_time_waypoint_graph_data": {
          "type": "object",
          "title": "UpdateWaypointGraphData",
          "default": {},
          "example": null,
          "nullable": true,
          "properties": {
            "waypoint_graph": {
              "type": "object",
              "title": "Waypoint Graph",
              "nullable": true,
              "additionalProperties": {
                "type": "object",
                "title": "WaypointGraph",
                "required": [
                  "edges",
                  "offsets"
                ],
                "properties": {
                  "edges": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    },
                    "title": "Edges",
                    "description": "dtype: int32, edge >= 0. \n\n Vertices of all the directed edges."
                  },
                  "offsets": {
                    "type": "array",
                    "items": {
                      "type": "integer",
                      "maximum": 2147483647,
                      "minimum": 0
                    },
                    "title": "Offsets",
                    "description": "dtype: int32, offset >= 0. \n\n Offsets which provide number of edges from the source vertex signified by the index."
                  },
                  "weights": {
                    "type": "array",
                    "items": {
                      "type": "number",
                      "minimum": 0
                    },
                    "title": "Weights",
                    "nullable": true,
                    "description": "dtype: float32, weight >= 0. \n\n Weights of each edges."
                  }
                }
              }
            }
          },
          "x-examples": [
            null
          ],
          "description": "Waypoint graph with weights as time to travel from A to B \nand B to A. If there are different types of vehicles \nthey can be provided with key value pair \nwhere key is vehicle-type and value is the graph. Value of \nvehicle type should be within [0, 255]"
        }
      },
      "description": "The data that needs to be processed by the service. For detailed explanations of each field, please consult the following link: <a href=\"https://docs.nvidia.com/cuopt/service/latest/data-requirements.html\">data requirements</a> . To ensure best practices, please refer to: <a href=\"https://docs.nvidia.com/cuopt/service/latest/best-practices.html\">best practices</a>. For examples, you can find them at: <a href=\"https://github.com/NVIDIA/cuOpt-Resources/tree/branch-23.10/notebooks/routing/service\">notebooks</a>. If the size of the data exceeds 250KB, please utilize the large assets API to upload it to s3. In such cases, set the data as null and include the header NVCF-INPUT-ASSET-REFERENCES: $ASSET_ID in the POST request."
    },
    "action": {
      "enum": [
        "cuOpt_OptimizedRouting",
        "cuOpt_RoutingValidator",
        "0"
      ],
      "type": "string",
      "title": "Action",
      "default": "cuOpt_OptimizedRouting",
      "nullable": true,
      "description": "Action to be performed by the service, validator action just validates input against format and base rules."
    },
    "parameters": {
      "type": "object",
      "title": "Parameters",
      "nullable": true,
      "description": "unused/ignored but retained for compatibility"
    },
    "client_version": {
      "type": "string",
      "title": "Client Version",
      "default": "",
      "nullable": true,
      "description": "cuOpt client version. Set to 'custom' to skip version check."
    }
  }
}