@delpa/mt-prisma 0.8.0 → 0.10.0

package/dist/generated/generated/client/index.d.ts

@@ -83,11 +83,6 @@ export type Route = $Result.DefaultSelection<Prisma.$RoutePayload>
  * 
  */
 export type RouteHandlingUnit = $Result.DefaultSelection<Prisma.$RouteHandlingUnitPayload>
-/**
- * Model RouteOrders
- * 
- */
-export type RouteOrders = $Result.DefaultSelection<Prisma.$RouteOrdersPayload>
 /**
  * Model Address
  * 
@@ -180,15 +175,6 @@ export const FuelType: {
 export type FuelType = (typeof FuelType)[keyof typeof FuelType]
 
 
-export const TypeOfRoutes: {
-  PICKING: 'PICKING',
-  DELIVERY: 'DELIVERY',
-  RETURN: 'RETURN'
-};
-
-export type TypeOfRoutes = (typeof TypeOfRoutes)[keyof typeof TypeOfRoutes]
-
-
 export const AddressType: {
   PICKUP: 'PICKUP',
   DELIVERY: 'DELIVERY',
@@ -242,10 +228,6 @@ export type FuelType = $Enums.FuelType
 
 export const FuelType: typeof $Enums.FuelType
 
-export type TypeOfRoutes = $Enums.TypeOfRoutes
-
-export const TypeOfRoutes: typeof $Enums.TypeOfRoutes
-
 export type AddressType = $Enums.AddressType
 
 export const AddressType: typeof $Enums.AddressType
@@ -507,16 +489,6 @@ export class PrismaClient<
     */
   get routeHandlingUnit(): Prisma.RouteHandlingUnitDelegate<ExtArgs, ClientOptions>;
 
-  /**
-   * `prisma.routeOrders`: Exposes CRUD operations for the **RouteOrders** model.
-    * Example usage:
-    * ```ts
-    * // Fetch zero or more RouteOrders
-    * const routeOrders = await prisma.routeOrders.findMany()
-    * ```
-    */
-  get routeOrders(): Prisma.RouteOrdersDelegate<ExtArgs, ClientOptions>;
-
   /**
    * `prisma.address`: Exposes CRUD operations for the **Address** model.
     * Example usage:
@@ -984,7 +956,6 @@ export namespace Prisma {
     Vehicle: 'Vehicle',
     Route: 'Route',
     RouteHandlingUnit: 'RouteHandlingUnit',
-    RouteOrders: 'RouteOrders',
     Address: 'Address',
     AddressHandlingUnit: 'AddressHandlingUnit'
   };
@@ -1002,7 +973,7 @@ export namespace Prisma {
       omit: GlobalOmitOptions
     }
     meta: {
-      modelProps: "client" | "clientAddress" | "clientContact" | "order" | "companies" | "handlingUnit" | "user" | "userCompany" | "session" | "vehicleBrand" | "vehicleModel" | "vehicle" | "route" | "routeHandlingUnit" | "routeOrders" | "address" | "addressHandlingUnit"
+      modelProps: "client" | "clientAddress" | "clientContact" | "order" | "companies" | "handlingUnit" | "user" | "userCompany" | "session" | "vehicleBrand" | "vehicleModel" | "vehicle" | "route" | "routeHandlingUnit" | "address" | "addressHandlingUnit"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -2042,80 +2013,6 @@ export namespace Prisma {
           }
         }
       }
-      RouteOrders: {
-        payload: Prisma.$RouteOrdersPayload<ExtArgs>
-        fields: Prisma.RouteOrdersFieldRefs
-        operations: {
-          findUnique: {
-            args: Prisma.RouteOrdersFindUniqueArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload> | null
-          }
-          findUniqueOrThrow: {
-            args: Prisma.RouteOrdersFindUniqueOrThrowArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>
-          }
-          findFirst: {
-            args: Prisma.RouteOrdersFindFirstArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload> | null
-          }
-          findFirstOrThrow: {
-            args: Prisma.RouteOrdersFindFirstOrThrowArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>
-          }
-          findMany: {
-            args: Prisma.RouteOrdersFindManyArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>[]
-          }
-          create: {
-            args: Prisma.RouteOrdersCreateArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>
-          }
-          createMany: {
-            args: Prisma.RouteOrdersCreateManyArgs<ExtArgs>
-            result: BatchPayload
-          }
-          createManyAndReturn: {
-            args: Prisma.RouteOrdersCreateManyAndReturnArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>[]
-          }
-          delete: {
-            args: Prisma.RouteOrdersDeleteArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>
-          }
-          update: {
-            args: Prisma.RouteOrdersUpdateArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>
-          }
-          deleteMany: {
-            args: Prisma.RouteOrdersDeleteManyArgs<ExtArgs>
-            result: BatchPayload
-          }
-          updateMany: {
-            args: Prisma.RouteOrdersUpdateManyArgs<ExtArgs>
-            result: BatchPayload
-          }
-          updateManyAndReturn: {
-            args: Prisma.RouteOrdersUpdateManyAndReturnArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>[]
-          }
-          upsert: {
-            args: Prisma.RouteOrdersUpsertArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$RouteOrdersPayload>
-          }
-          aggregate: {
-            args: Prisma.RouteOrdersAggregateArgs<ExtArgs>
-            result: $Utils.Optional<AggregateRouteOrders>
-          }
-          groupBy: {
-            args: Prisma.RouteOrdersGroupByArgs<ExtArgs>
-            result: $Utils.Optional<RouteOrdersGroupByOutputType>[]
-          }
-          count: {
-            args: Prisma.RouteOrdersCountArgs<ExtArgs>
-            result: $Utils.Optional<RouteOrdersCountAggregateOutputType> | number
-          }
-        }
-      }
       Address: {
         payload: Prisma.$AddressPayload<ExtArgs>
         fields: Prisma.AddressFieldRefs
@@ -2386,7 +2283,6 @@ export namespace Prisma {
     vehicle?: VehicleOmit
     route?: RouteOmit
     routeHandlingUnit?: RouteHandlingUnitOmit
-    routeOrders?: RouteOrdersOmit
     address?: AddressOmit
     addressHandlingUnit?: AddressHandlingUnitOmit
   }
@@ -2528,12 +2424,12 @@ export namespace Prisma {
 
   export type OrderCountOutputType = {
     handling_units: number
-    route_orders: number
+    routes: number
   }
 
   export type OrderCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     handling_units?: boolean | OrderCountOutputTypeCountHandling_unitsArgs
-    route_orders?: boolean | OrderCountOutputTypeCountRoute_ordersArgs
+    routes?: boolean | OrderCountOutputTypeCountRoutesArgs
   }
 
   // Custom InputTypes
@@ -2557,8 +2453,8 @@ export namespace Prisma {
   /**
    * OrderCountOutputType without action
    */
-  export type OrderCountOutputTypeCountRoute_ordersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: RouteOrdersWhereInput
+  export type OrderCountOutputTypeCountRoutesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: RouteWhereInput
   }
 
 
@@ -2808,13 +2704,11 @@ export namespace Prisma {
 
   export type RouteCountOutputType = {
     route_handling_units: number
-    route_orders: number
     addresses: number
   }
 
   export type RouteCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     route_handling_units?: boolean | RouteCountOutputTypeCountRoute_handling_unitsArgs
-    route_orders?: boolean | RouteCountOutputTypeCountRoute_ordersArgs
     addresses?: boolean | RouteCountOutputTypeCountAddressesArgs
   }
 
@@ -2836,13 +2730,6 @@ export namespace Prisma {
     where?: RouteHandlingUnitWhereInput
   }
 
-  /**
-   * RouteCountOutputType without action
-   */
-  export type RouteCountOutputTypeCountRoute_ordersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: RouteOrdersWhereInput
-  }
-
   /**
    * RouteCountOutputType without action
    */
@@ -6656,7 +6543,7 @@ export namespace Prisma {
     updated_at?: boolean
     shipper?: boolean | Order$shipperArgs<ExtArgs>
     handling_units?: boolean | Order$handling_unitsArgs<ExtArgs>
-    route_orders?: boolean | Order$route_ordersArgs<ExtArgs>
+    routes?: boolean | Order$routesArgs<ExtArgs>
     _count?: boolean | OrderCountOutputTypeDefaultArgs<ExtArgs>
   }, ExtArgs["result"]["order"]>
 
@@ -6696,7 +6583,7 @@ export namespace Prisma {
   export type OrderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     shipper?: boolean | Order$shipperArgs<ExtArgs>
     handling_units?: boolean | Order$handling_unitsArgs<ExtArgs>
-    route_orders?: boolean | Order$route_ordersArgs<ExtArgs>
+    routes?: boolean | Order$routesArgs<ExtArgs>
     _count?: boolean | OrderCountOutputTypeDefaultArgs<ExtArgs>
   }
   export type OrderIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
@@ -6711,7 +6598,7 @@ export namespace Prisma {
     objects: {
       shipper: Prisma.$ClientPayload<ExtArgs> | null
       handling_units: Prisma.$HandlingUnitPayload<ExtArgs>[]
-      route_orders: Prisma.$RouteOrdersPayload<ExtArgs>[]
+      routes: Prisma.$RoutePayload<ExtArgs>[]
     }
     scalars: $Extensions.GetPayloadResult<{
       id: string
@@ -7117,7 +7004,7 @@ export namespace Prisma {
     readonly [Symbol.toStringTag]: "PrismaPromise"
     shipper<T extends Order$shipperArgs<ExtArgs> = {}>(args?: Subset<T, Order$shipperArgs<ExtArgs>>): Prisma__ClientClient<$Result.GetResult<Prisma.$ClientPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
     handling_units<T extends Order$handling_unitsArgs<ExtArgs> = {}>(args?: Subset<T, Order$handling_unitsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HandlingUnitPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
-    route_orders<T extends Order$route_ordersArgs<ExtArgs> = {}>(args?: Subset<T, Order$route_ordersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+    routes<T extends Order$routesArgs<ExtArgs> = {}>(args?: Subset<T, Order$routesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RoutePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
     /**
      * Attaches callbacks for the resolution and/or rejection of the Promise.
      * @param onfulfilled The callback to execute when the Promise is resolved.
@@ -7593,27 +7480,27 @@ export namespace Prisma {
   }
 
   /**
-   * Order.route_orders
+   * Order.routes
    */
-  export type Order$route_ordersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type Order$routesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RouteOrders
+     * Select specific fields to fetch from the Route
      */
-    select?: RouteOrdersSelect<ExtArgs> | null
+    select?: RouteSelect<ExtArgs> | null
     /**
-     * Omit specific fields from the RouteOrders
+     * Omit specific fields from the Route
      */
-    omit?: RouteOrdersOmit<ExtArgs> | null
+    omit?: RouteOmit<ExtArgs> | null
     /**
      * Choose, which related nodes to fetch as well
      */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    where?: RouteOrdersWhereInput
-    orderBy?: RouteOrdersOrderByWithRelationInput | RouteOrdersOrderByWithRelationInput[]
-    cursor?: RouteOrdersWhereUniqueInput
+    include?: RouteInclude<ExtArgs> | null
+    where?: RouteWhereInput
+    orderBy?: RouteOrderByWithRelationInput | RouteOrderByWithRelationInput[]
+    cursor?: RouteWhereUniqueInput
     take?: number
     skip?: number
-    distinct?: RouteOrdersScalarFieldEnum | RouteOrdersScalarFieldEnum[]
+    distinct?: RouteScalarFieldEnum | RouteScalarFieldEnum[]
   }
 
   /**
@@ -17114,36 +17001,36 @@ export namespace Prisma {
 
   export type RouteMinAggregateOutputType = {
     id: string | null
+    order_id: string | null
     driver_id: string | null
     vehicle_id: string | null
     status: $Enums.RouteStatus | null
     started_at: Date | null
     completed_at: Date | null
-    type_of_route: $Enums.TypeOfRoutes | null
     created_at: Date | null
     updated_at: Date | null
   }
 
   export type RouteMaxAggregateOutputType = {
     id: string | null
+    order_id: string | null
     driver_id: string | null
     vehicle_id: string | null
     status: $Enums.RouteStatus | null
     started_at: Date | null
     completed_at: Date | null
-    type_of_route: $Enums.TypeOfRoutes | null
     created_at: Date | null
     updated_at: Date | null
   }
 
   export type RouteCountAggregateOutputType = {
     id: number
+    order_id: number
     driver_id: number
     vehicle_id: number
     status: number
     started_at: number
     completed_at: number
-    type_of_route: number
     created_at: number
     updated_at: number
     _all: number
@@ -17152,36 +17039,36 @@ export namespace Prisma {
 
   export type RouteMinAggregateInputType = {
     id?: true
+    order_id?: true
     driver_id?: true
     vehicle_id?: true
     status?: true
     started_at?: true
     completed_at?: true
-    type_of_route?: true
     created_at?: true
     updated_at?: true
   }
 
   export type RouteMaxAggregateInputType = {
     id?: true
+    order_id?: true
     driver_id?: true
     vehicle_id?: true
     status?: true
     started_at?: true
     completed_at?: true
-    type_of_route?: true
     created_at?: true
     updated_at?: true
   }
 
   export type RouteCountAggregateInputType = {
     id?: true
+    order_id?: true
     driver_id?: true
     vehicle_id?: true
     status?: true
     started_at?: true
     completed_at?: true
-    type_of_route?: true
     created_at?: true
     updated_at?: true
     _all?: true
@@ -17261,12 +17148,12 @@ export namespace Prisma {
 
   export type RouteGroupByOutputType = {
     id: string
+    order_id: string | null
     driver_id: string | null
     vehicle_id: string | null
     status: $Enums.RouteStatus
     started_at: Date | null
     completed_at: Date | null
-    type_of_route: $Enums.TypeOfRoutes | null
     created_at: Date
     updated_at: Date
     _count: RouteCountAggregateOutputType | null
@@ -17290,76 +17177,80 @@ export namespace Prisma {
 
   export type RouteSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
+    order_id?: boolean
     driver_id?: boolean
     vehicle_id?: boolean
     status?: boolean
     started_at?: boolean
     completed_at?: boolean
-    type_of_route?: boolean
     created_at?: boolean
     updated_at?: boolean
+    order?: boolean | Route$orderArgs<ExtArgs>
     driver?: boolean | Route$driverArgs<ExtArgs>
     vehicle?: boolean | Route$vehicleArgs<ExtArgs>
     route_handling_units?: boolean | Route$route_handling_unitsArgs<ExtArgs>
-    route_orders?: boolean | Route$route_ordersArgs<ExtArgs>
     addresses?: boolean | Route$addressesArgs<ExtArgs>
     _count?: boolean | RouteCountOutputTypeDefaultArgs<ExtArgs>
   }, ExtArgs["result"]["route"]>
 
   export type RouteSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
+    order_id?: boolean
     driver_id?: boolean
     vehicle_id?: boolean
     status?: boolean
     started_at?: boolean
     completed_at?: boolean
-    type_of_route?: boolean
     created_at?: boolean
     updated_at?: boolean
+    order?: boolean | Route$orderArgs<ExtArgs>
     driver?: boolean | Route$driverArgs<ExtArgs>
     vehicle?: boolean | Route$vehicleArgs<ExtArgs>
   }, ExtArgs["result"]["route"]>
 
   export type RouteSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
+    order_id?: boolean
     driver_id?: boolean
     vehicle_id?: boolean
     status?: boolean
     started_at?: boolean
     completed_at?: boolean
-    type_of_route?: boolean
     created_at?: boolean
     updated_at?: boolean
+    order?: boolean | Route$orderArgs<ExtArgs>
     driver?: boolean | Route$driverArgs<ExtArgs>
     vehicle?: boolean | Route$vehicleArgs<ExtArgs>
   }, ExtArgs["result"]["route"]>
 
   export type RouteSelectScalar = {
     id?: boolean
+    order_id?: boolean
     driver_id?: boolean
     vehicle_id?: boolean
     status?: boolean
     started_at?: boolean
     completed_at?: boolean
-    type_of_route?: boolean
     created_at?: boolean
     updated_at?: boolean
   }
 
-  export type RouteOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "driver_id" | "vehicle_id" | "status" | "started_at" | "completed_at" | "type_of_route" | "created_at" | "updated_at", ExtArgs["result"]["route"]>
+  export type RouteOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "order_id" | "driver_id" | "vehicle_id" | "status" | "started_at" | "completed_at" | "created_at" | "updated_at", ExtArgs["result"]["route"]>
   export type RouteInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    order?: boolean | Route$orderArgs<ExtArgs>
     driver?: boolean | Route$driverArgs<ExtArgs>
     vehicle?: boolean | Route$vehicleArgs<ExtArgs>
     route_handling_units?: boolean | Route$route_handling_unitsArgs<ExtArgs>
-    route_orders?: boolean | Route$route_ordersArgs<ExtArgs>
     addresses?: boolean | Route$addressesArgs<ExtArgs>
     _count?: boolean | RouteCountOutputTypeDefaultArgs<ExtArgs>
   }
   export type RouteIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    order?: boolean | Route$orderArgs<ExtArgs>
     driver?: boolean | Route$driverArgs<ExtArgs>
     vehicle?: boolean | Route$vehicleArgs<ExtArgs>
   }
   export type RouteIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    order?: boolean | Route$orderArgs<ExtArgs>
     driver?: boolean | Route$driverArgs<ExtArgs>
     vehicle?: boolean | Route$vehicleArgs<ExtArgs>
   }
@@ -17367,20 +17258,20 @@ export namespace Prisma {
   export type $RoutePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     name: "Route"
     objects: {
+      order: Prisma.$OrderPayload<ExtArgs> | null
       driver: Prisma.$UserPayload<ExtArgs> | null
       vehicle: Prisma.$VehiclePayload<ExtArgs> | null
       route_handling_units: Prisma.$RouteHandlingUnitPayload<ExtArgs>[]
-      route_orders: Prisma.$RouteOrdersPayload<ExtArgs>[]
       addresses: Prisma.$AddressPayload<ExtArgs>[]
     }
     scalars: $Extensions.GetPayloadResult<{
       id: string
+      order_id: string | null
       driver_id: string | null
       vehicle_id: string | null
       status: $Enums.RouteStatus
       started_at: Date | null
       completed_at: Date | null
-      type_of_route: $Enums.TypeOfRoutes | null
       created_at: Date
       updated_at: Date
     }, ExtArgs["result"]["route"]>
@@ -17777,10 +17668,10 @@ export namespace Prisma {
    */
   export interface Prisma__RouteClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
     readonly [Symbol.toStringTag]: "PrismaPromise"
+    order<T extends Route$orderArgs<ExtArgs> = {}>(args?: Subset<T, Route$orderArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
     driver<T extends Route$driverArgs<ExtArgs> = {}>(args?: Subset<T, Route$driverArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
     vehicle<T extends Route$vehicleArgs<ExtArgs> = {}>(args?: Subset<T, Route$vehicleArgs<ExtArgs>>): Prisma__VehicleClient<$Result.GetResult<Prisma.$VehiclePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
     route_handling_units<T extends Route$route_handling_unitsArgs<ExtArgs> = {}>(args?: Subset<T, Route$route_handling_unitsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RouteHandlingUnitPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
-    route_orders<T extends Route$route_ordersArgs<ExtArgs> = {}>(args?: Subset<T, Route$route_ordersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
     addresses<T extends Route$addressesArgs<ExtArgs> = {}>(args?: Subset<T, Route$addressesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
     /**
      * Attaches callbacks for the resolution and/or rejection of the Promise.
@@ -17812,12 +17703,12 @@ export namespace Prisma {
    */
   interface RouteFieldRefs {
     readonly id: FieldRef<"Route", 'String'>
+    readonly order_id: FieldRef<"Route", 'String'>
     readonly driver_id: FieldRef<"Route", 'String'>
     readonly vehicle_id: FieldRef<"Route", 'String'>
     readonly status: FieldRef<"Route", 'RouteStatus'>
     readonly started_at: FieldRef<"Route", 'DateTime'>
     readonly completed_at: FieldRef<"Route", 'DateTime'>
-    readonly type_of_route: FieldRef<"Route", 'TypeOfRoutes'>
     readonly created_at: FieldRef<"Route", 'DateTime'>
     readonly updated_at: FieldRef<"Route", 'DateTime'>
   }
@@ -18215,6 +18106,25 @@ export namespace Prisma {
     limit?: number
   }
 
+  /**
+   * Route.order
+   */
+  export type Route$orderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Order
+     */
+    select?: OrderSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Order
+     */
+    omit?: OrderOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: OrderInclude<ExtArgs> | null
+    where?: OrderWhereInput
+  }
+
   /**
    * Route.driver
    */
@@ -18277,30 +18187,6 @@ export namespace Prisma {
     distinct?: RouteHandlingUnitScalarFieldEnum | RouteHandlingUnitScalarFieldEnum[]
   }
 
-  /**
-   * Route.route_orders
-   */
-  export type Route$route_ordersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    where?: RouteOrdersWhereInput
-    orderBy?: RouteOrdersOrderByWithRelationInput | RouteOrdersOrderByWithRelationInput[]
-    cursor?: RouteOrdersWhereUniqueInput
-    take?: number
-    skip?: number
-    distinct?: RouteOrdersScalarFieldEnum | RouteOrdersScalarFieldEnum[]
-  }
-
   /**
    * Route.addresses
    */
@@ -19411,1285 +19297,219 @@ export namespace Prisma {
 
 
   /**
-   * Model RouteOrders
+   * Model Address
    */
 
-  export type AggregateRouteOrders = {
-    _count: RouteOrdersCountAggregateOutputType | null
-    _min: RouteOrdersMinAggregateOutputType | null
-    _max: RouteOrdersMaxAggregateOutputType | null
+  export type AggregateAddress = {
+    _count: AddressCountAggregateOutputType | null
+    _avg: AddressAvgAggregateOutputType | null
+    _sum: AddressSumAggregateOutputType | null
+    _min: AddressMinAggregateOutputType | null
+    _max: AddressMaxAggregateOutputType | null
+  }
+
+  export type AddressAvgAggregateOutputType = {
+    sequence: number | null
+    latitude: number | null
+    longitude: number | null
+  }
+
+  export type AddressSumAggregateOutputType = {
+    sequence: number | null
+    latitude: number | null
+    longitude: number | null
   }
 
-  export type RouteOrdersMinAggregateOutputType = {
+  export type AddressMinAggregateOutputType = {
     id: string | null
+    address_type: $Enums.AddressType | null
+    sequence: number | null
+    title: string | null
+    address_line1: string | null
+    address_line2: string | null
+    apartment: string | null
+    city: string | null
+    state: string | null
+    postal_code: string | null
+    country: string | null
+    latitude: number | null
+    longitude: number | null
     route_id: string | null
-    order_id: string | null
     created_at: Date | null
     updated_at: Date | null
   }
 
-  export type RouteOrdersMaxAggregateOutputType = {
+  export type AddressMaxAggregateOutputType = {
     id: string | null
+    address_type: $Enums.AddressType | null
+    sequence: number | null
+    title: string | null
+    address_line1: string | null
+    address_line2: string | null
+    apartment: string | null
+    city: string | null
+    state: string | null
+    postal_code: string | null
+    country: string | null
+    latitude: number | null
+    longitude: number | null
     route_id: string | null
-    order_id: string | null
     created_at: Date | null
     updated_at: Date | null
   }
 
-  export type RouteOrdersCountAggregateOutputType = {
+  export type AddressCountAggregateOutputType = {
     id: number
+    address_type: number
+    sequence: number
+    title: number
+    address_line1: number
+    address_line2: number
+    apartment: number
+    city: number
+    state: number
+    postal_code: number
+    country: number
+    latitude: number
+    longitude: number
+    google_address: number
     route_id: number
-    order_id: number
     created_at: number
     updated_at: number
     _all: number
   }
 
 
-  export type RouteOrdersMinAggregateInputType = {
+  export type AddressAvgAggregateInputType = {
+    sequence?: true
+    latitude?: true
+    longitude?: true
+  }
+
+  export type AddressSumAggregateInputType = {
+    sequence?: true
+    latitude?: true
+    longitude?: true
+  }
+
+  export type AddressMinAggregateInputType = {
     id?: true
+    address_type?: true
+    sequence?: true
+    title?: true
+    address_line1?: true
+    address_line2?: true
+    apartment?: true
+    city?: true
+    state?: true
+    postal_code?: true
+    country?: true
+    latitude?: true
+    longitude?: true
     route_id?: true
-    order_id?: true
     created_at?: true
     updated_at?: true
   }
 
-  export type RouteOrdersMaxAggregateInputType = {
+  export type AddressMaxAggregateInputType = {
     id?: true
+    address_type?: true
+    sequence?: true
+    title?: true
+    address_line1?: true
+    address_line2?: true
+    apartment?: true
+    city?: true
+    state?: true
+    postal_code?: true
+    country?: true
+    latitude?: true
+    longitude?: true
     route_id?: true
-    order_id?: true
     created_at?: true
     updated_at?: true
   }
 
-  export type RouteOrdersCountAggregateInputType = {
+  export type AddressCountAggregateInputType = {
     id?: true
+    address_type?: true
+    sequence?: true
+    title?: true
+    address_line1?: true
+    address_line2?: true
+    apartment?: true
+    city?: true
+    state?: true
+    postal_code?: true
+    country?: true
+    latitude?: true
+    longitude?: true
+    google_address?: true
     route_id?: true
-    order_id?: true
     created_at?: true
     updated_at?: true
     _all?: true
   }
 
-  export type RouteOrdersAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type AddressAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Filter which RouteOrders to aggregate.
+     * Filter which Address to aggregate.
      */
-    where?: RouteOrdersWhereInput
+    where?: AddressWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of RouteOrders to fetch.
+     * Determine the order of Addresses to fetch.
      */
-    orderBy?: RouteOrdersOrderByWithRelationInput | RouteOrdersOrderByWithRelationInput[]
+    orderBy?: AddressOrderByWithRelationInput | AddressOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
      * Sets the start position
      */
-    cursor?: RouteOrdersWhereUniqueInput
+    cursor?: AddressWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` RouteOrders from the position of the cursor.
+     * Take `±n` Addresses from the position of the cursor.
      */
     take?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Skip the first `n` RouteOrders.
+     * Skip the first `n` Addresses.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
-     * Count returned RouteOrders
+     * Count returned Addresses
+    **/
+    _count?: true | AddressCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to average
+    **/
+    _avg?: AddressAvgAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to sum
     **/
-    _count?: true | RouteOrdersCountAggregateInputType
+    _sum?: AddressSumAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the minimum value
     **/
-    _min?: RouteOrdersMinAggregateInputType
+    _min?: AddressMinAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the maximum value
     **/
-    _max?: RouteOrdersMaxAggregateInputType
-  }
-
-  export type GetRouteOrdersAggregateType<T extends RouteOrdersAggregateArgs> = {
-        [P in keyof T & keyof AggregateRouteOrders]: P extends '_count' | 'count'
-      ? T[P] extends true
-        ? number
-        : GetScalarType<T[P], AggregateRouteOrders[P]>
-      : GetScalarType<T[P], AggregateRouteOrders[P]>
-  }
-
-
-
-
-  export type RouteOrdersGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: RouteOrdersWhereInput
-    orderBy?: RouteOrdersOrderByWithAggregationInput | RouteOrdersOrderByWithAggregationInput[]
-    by: RouteOrdersScalarFieldEnum[] | RouteOrdersScalarFieldEnum
-    having?: RouteOrdersScalarWhereWithAggregatesInput
-    take?: number
-    skip?: number
-    _count?: RouteOrdersCountAggregateInputType | true
-    _min?: RouteOrdersMinAggregateInputType
-    _max?: RouteOrdersMaxAggregateInputType
-  }
-
-  export type RouteOrdersGroupByOutputType = {
-    id: string
-    route_id: string
-    order_id: string
-    created_at: Date
-    updated_at: Date
-    _count: RouteOrdersCountAggregateOutputType | null
-    _min: RouteOrdersMinAggregateOutputType | null
-    _max: RouteOrdersMaxAggregateOutputType | null
-  }
-
-  type GetRouteOrdersGroupByPayload<T extends RouteOrdersGroupByArgs> = Prisma.PrismaPromise<
-    Array<
-      PickEnumerable<RouteOrdersGroupByOutputType, T['by']> &
-        {
-          [P in ((keyof T) & (keyof RouteOrdersGroupByOutputType))]: P extends '_count'
-            ? T[P] extends boolean
-              ? number
-              : GetScalarType<T[P], RouteOrdersGroupByOutputType[P]>
-            : GetScalarType<T[P], RouteOrdersGroupByOutputType[P]>
-        }
-      >
-    >
-
-
-  export type RouteOrdersSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
-    id?: boolean
-    route_id?: boolean
-    order_id?: boolean
-    created_at?: boolean
-    updated_at?: boolean
-    route?: boolean | RouteDefaultArgs<ExtArgs>
-    order?: boolean | OrderDefaultArgs<ExtArgs>
-  }, ExtArgs["result"]["routeOrders"]>
-
-  export type RouteOrdersSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
-    id?: boolean
-    route_id?: boolean
-    order_id?: boolean
-    created_at?: boolean
-    updated_at?: boolean
-    route?: boolean | RouteDefaultArgs<ExtArgs>
-    order?: boolean | OrderDefaultArgs<ExtArgs>
-  }, ExtArgs["result"]["routeOrders"]>
-
-  export type RouteOrdersSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
-    id?: boolean
-    route_id?: boolean
-    order_id?: boolean
-    created_at?: boolean
-    updated_at?: boolean
-    route?: boolean | RouteDefaultArgs<ExtArgs>
-    order?: boolean | OrderDefaultArgs<ExtArgs>
-  }, ExtArgs["result"]["routeOrders"]>
-
-  export type RouteOrdersSelectScalar = {
-    id?: boolean
-    route_id?: boolean
-    order_id?: boolean
-    created_at?: boolean
-    updated_at?: boolean
-  }
-
-  export type RouteOrdersOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "route_id" | "order_id" | "created_at" | "updated_at", ExtArgs["result"]["routeOrders"]>
-  export type RouteOrdersInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    route?: boolean | RouteDefaultArgs<ExtArgs>
-    order?: boolean | OrderDefaultArgs<ExtArgs>
-  }
-  export type RouteOrdersIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    route?: boolean | RouteDefaultArgs<ExtArgs>
-    order?: boolean | OrderDefaultArgs<ExtArgs>
-  }
-  export type RouteOrdersIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    route?: boolean | RouteDefaultArgs<ExtArgs>
-    order?: boolean | OrderDefaultArgs<ExtArgs>
-  }
-
-  export type $RouteOrdersPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    name: "RouteOrders"
-    objects: {
-      route: Prisma.$RoutePayload<ExtArgs>
-      order: Prisma.$OrderPayload<ExtArgs>
-    }
-    scalars: $Extensions.GetPayloadResult<{
-      id: string
-      route_id: string
-      order_id: string
-      created_at: Date
-      updated_at: Date
-    }, ExtArgs["result"]["routeOrders"]>
-    composites: {}
-  }
-
-  type RouteOrdersGetPayload<S extends boolean | null | undefined | RouteOrdersDefaultArgs> = $Result.GetResult<Prisma.$RouteOrdersPayload, S>
-
-  type RouteOrdersCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
-    Omit<RouteOrdersFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
-      select?: RouteOrdersCountAggregateInputType | true
-    }
-
-  export interface RouteOrdersDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
-    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['RouteOrders'], meta: { name: 'RouteOrders' } }
-    /**
-     * Find zero or one RouteOrders that matches the filter.
-     * @param {RouteOrdersFindUniqueArgs} args - Arguments to find a RouteOrders
-     * @example
-     * // Get one RouteOrders
-     * const routeOrders = await prisma.routeOrders.findUnique({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findUnique<T extends RouteOrdersFindUniqueArgs>(args: SelectSubset<T, RouteOrdersFindUniqueArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
-
-    /**
-     * Find one RouteOrders that matches the filter or throw an error with `error.code='P2025'`
-     * if no matches were found.
-     * @param {RouteOrdersFindUniqueOrThrowArgs} args - Arguments to find a RouteOrders
-     * @example
-     * // Get one RouteOrders
-     * const routeOrders = await prisma.routeOrders.findUniqueOrThrow({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findUniqueOrThrow<T extends RouteOrdersFindUniqueOrThrowArgs>(args: SelectSubset<T, RouteOrdersFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
-
-    /**
-     * Find the first RouteOrders that matches the filter.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {RouteOrdersFindFirstArgs} args - Arguments to find a RouteOrders
-     * @example
-     * // Get one RouteOrders
-     * const routeOrders = await prisma.routeOrders.findFirst({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findFirst<T extends RouteOrdersFindFirstArgs>(args?: SelectSubset<T, RouteOrdersFindFirstArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
-
-    /**
-     * Find the first RouteOrders that matches the filter or
-     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {RouteOrdersFindFirstOrThrowArgs} args - Arguments to find a RouteOrders
-     * @example
-     * // Get one RouteOrders
-     * const routeOrders = await prisma.routeOrders.findFirstOrThrow({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findFirstOrThrow<T extends RouteOrdersFindFirstOrThrowArgs>(args?: SelectSubset<T, RouteOrdersFindFirstOrThrowArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
-
-    /**
-     * Find zero or more RouteOrders that matches the filter.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {RouteOrdersFindManyArgs} args - Arguments to filter and select certain fields only.
-     * @example
-     * // Get all RouteOrders
-     * const routeOrders = await prisma.routeOrders.findMany()
-     * 
-     * // Get first 10 RouteOrders
-     * const routeOrders = await prisma.routeOrders.findMany({ take: 10 })
-     * 
-     * // Only select the `id`
-     * const routeOrdersWithIdOnly = await prisma.routeOrders.findMany({ select: { id: true } })
-     * 
-     */
-    findMany<T extends RouteOrdersFindManyArgs>(args?: SelectSubset<T, RouteOrdersFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
-
-    /**
-     * Create a RouteOrders.
-     * @param {RouteOrdersCreateArgs} args - Arguments to create a RouteOrders.
-     * @example
-     * // Create one RouteOrders
-     * const RouteOrders = await prisma.routeOrders.create({
-     *   data: {
-     *     // ... data to create a RouteOrders
-     *   }
-     * })
-     * 
-     */
-    create<T extends RouteOrdersCreateArgs>(args: SelectSubset<T, RouteOrdersCreateArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
-
-    /**
-     * Create many RouteOrders.
-     * @param {RouteOrdersCreateManyArgs} args - Arguments to create many RouteOrders.
-     * @example
-     * // Create many RouteOrders
-     * const routeOrders = await prisma.routeOrders.createMany({
-     *   data: [
-     *     // ... provide data here
-     *   ]
-     * })
-     *     
-     */
-    createMany<T extends RouteOrdersCreateManyArgs>(args?: SelectSubset<T, RouteOrdersCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
-
-    /**
-     * Create many RouteOrders and returns the data saved in the database.
-     * @param {RouteOrdersCreateManyAndReturnArgs} args - Arguments to create many RouteOrders.
-     * @example
-     * // Create many RouteOrders
-     * const routeOrders = await prisma.routeOrders.createManyAndReturn({
-     *   data: [
-     *     // ... provide data here
-     *   ]
-     * })
-     * 
-     * // Create many RouteOrders and only return the `id`
-     * const routeOrdersWithIdOnly = await prisma.routeOrders.createManyAndReturn({
-     *   select: { id: true },
-     *   data: [
-     *     // ... provide data here
-     *   ]
-     * })
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * 
-     */
-    createManyAndReturn<T extends RouteOrdersCreateManyAndReturnArgs>(args?: SelectSubset<T, RouteOrdersCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
-
-    /**
-     * Delete a RouteOrders.
-     * @param {RouteOrdersDeleteArgs} args - Arguments to delete one RouteOrders.
-     * @example
-     * // Delete one RouteOrders
-     * const RouteOrders = await prisma.routeOrders.delete({
-     *   where: {
-     *     // ... filter to delete one RouteOrders
-     *   }
-     * })
-     * 
-     */
-    delete<T extends RouteOrdersDeleteArgs>(args: SelectSubset<T, RouteOrdersDeleteArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
-
-    /**
-     * Update one RouteOrders.
-     * @param {RouteOrdersUpdateArgs} args - Arguments to update one RouteOrders.
-     * @example
-     * // Update one RouteOrders
-     * const routeOrders = await prisma.routeOrders.update({
-     *   where: {
-     *     // ... provide filter here
-     *   },
-     *   data: {
-     *     // ... provide data here
-     *   }
-     * })
-     * 
-     */
-    update<T extends RouteOrdersUpdateArgs>(args: SelectSubset<T, RouteOrdersUpdateArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
-
-    /**
-     * Delete zero or more RouteOrders.
-     * @param {RouteOrdersDeleteManyArgs} args - Arguments to filter RouteOrders to delete.
-     * @example
-     * // Delete a few RouteOrders
-     * const { count } = await prisma.routeOrders.deleteMany({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     * 
-     */
-    deleteMany<T extends RouteOrdersDeleteManyArgs>(args?: SelectSubset<T, RouteOrdersDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
-
-    /**
-     * Update zero or more RouteOrders.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {RouteOrdersUpdateManyArgs} args - Arguments to update one or more rows.
-     * @example
-     * // Update many RouteOrders
-     * const routeOrders = await prisma.routeOrders.updateMany({
-     *   where: {
-     *     // ... provide filter here
-     *   },
-     *   data: {
-     *     // ... provide data here
-     *   }
-     * })
-     * 
-     */
-    updateMany<T extends RouteOrdersUpdateManyArgs>(args: SelectSubset<T, RouteOrdersUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
-
-    /**
-     * Update zero or more RouteOrders and returns the data updated in the database.
-     * @param {RouteOrdersUpdateManyAndReturnArgs} args - Arguments to update many RouteOrders.
-     * @example
-     * // Update many RouteOrders
-     * const routeOrders = await prisma.routeOrders.updateManyAndReturn({
-     *   where: {
-     *     // ... provide filter here
-     *   },
-     *   data: [
-     *     // ... provide data here
-     *   ]
-     * })
-     * 
-     * // Update zero or more RouteOrders and only return the `id`
-     * const routeOrdersWithIdOnly = await prisma.routeOrders.updateManyAndReturn({
-     *   select: { id: true },
-     *   where: {
-     *     // ... provide filter here
-     *   },
-     *   data: [
-     *     // ... provide data here
-     *   ]
-     * })
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * 
-     */
-    updateManyAndReturn<T extends RouteOrdersUpdateManyAndReturnArgs>(args: SelectSubset<T, RouteOrdersUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
-
-    /**
-     * Create or update one RouteOrders.
-     * @param {RouteOrdersUpsertArgs} args - Arguments to update or create a RouteOrders.
-     * @example
-     * // Update or create a RouteOrders
-     * const routeOrders = await prisma.routeOrders.upsert({
-     *   create: {
-     *     // ... data to create a RouteOrders
-     *   },
-     *   update: {
-     *     // ... in case it already exists, update
-     *   },
-     *   where: {
-     *     // ... the filter for the RouteOrders we want to update
-     *   }
-     * })
-     */
-    upsert<T extends RouteOrdersUpsertArgs>(args: SelectSubset<T, RouteOrdersUpsertArgs<ExtArgs>>): Prisma__RouteOrdersClient<$Result.GetResult<Prisma.$RouteOrdersPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
-
-
-    /**
-     * Count the number of RouteOrders.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {RouteOrdersCountArgs} args - Arguments to filter RouteOrders to count.
-     * @example
-     * // Count the number of RouteOrders
-     * const count = await prisma.routeOrders.count({
-     *   where: {
-     *     // ... the filter for the RouteOrders we want to count
-     *   }
-     * })
-    **/
-    count<T extends RouteOrdersCountArgs>(
-      args?: Subset<T, RouteOrdersCountArgs>,
-    ): Prisma.PrismaPromise<
-      T extends $Utils.Record<'select', any>
-        ? T['select'] extends true
-          ? number
-          : GetScalarType<T['select'], RouteOrdersCountAggregateOutputType>
-        : number
-    >
-
-    /**
-     * Allows you to perform aggregations operations on a RouteOrders.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {RouteOrdersAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
-     * @example
-     * // Ordered by age ascending
-     * // Where email contains prisma.io
-     * // Limited to the 10 users
-     * const aggregations = await prisma.user.aggregate({
-     *   _avg: {
-     *     age: true,
-     *   },
-     *   where: {
-     *     email: {
-     *       contains: "prisma.io",
-     *     },
-     *   },
-     *   orderBy: {
-     *     age: "asc",
-     *   },
-     *   take: 10,
-     * })
-    **/
-    aggregate<T extends RouteOrdersAggregateArgs>(args: Subset<T, RouteOrdersAggregateArgs>): Prisma.PrismaPromise<GetRouteOrdersAggregateType<T>>
-
-    /**
-     * Group by RouteOrders.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {RouteOrdersGroupByArgs} args - Group by arguments.
-     * @example
-     * // Group by city, order by createdAt, get count
-     * const result = await prisma.user.groupBy({
-     *   by: ['city', 'createdAt'],
-     *   orderBy: {
-     *     createdAt: true
-     *   },
-     *   _count: {
-     *     _all: true
-     *   },
-     * })
-     * 
-    **/
-    groupBy<
-      T extends RouteOrdersGroupByArgs,
-      HasSelectOrTake extends Or<
-        Extends<'skip', Keys<T>>,
-        Extends<'take', Keys<T>>
-      >,
-      OrderByArg extends True extends HasSelectOrTake
-        ? { orderBy: RouteOrdersGroupByArgs['orderBy'] }
-        : { orderBy?: RouteOrdersGroupByArgs['orderBy'] },
-      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
-      ByFields extends MaybeTupleToUnion<T['by']>,
-      ByValid extends Has<ByFields, OrderFields>,
-      HavingFields extends GetHavingFields<T['having']>,
-      HavingValid extends Has<ByFields, HavingFields>,
-      ByEmpty extends T['by'] extends never[] ? True : False,
-      InputErrors extends ByEmpty extends True
-      ? `Error: "by" must not be empty.`
-      : HavingValid extends False
-      ? {
-          [P in HavingFields]: P extends ByFields
-            ? never
-            : P extends string
-            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
-            : [
-                Error,
-                'Field ',
-                P,
-                ` in "having" needs to be provided in "by"`,
-              ]
-        }[HavingFields]
-      : 'take' extends Keys<T>
-      ? 'orderBy' extends Keys<T>
-        ? ByValid extends True
-          ? {}
-          : {
-              [P in OrderFields]: P extends ByFields
-                ? never
-                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
-            }[OrderFields]
-        : 'Error: If you provide "take", you also need to provide "orderBy"'
-      : 'skip' extends Keys<T>
-      ? 'orderBy' extends Keys<T>
-        ? ByValid extends True
-          ? {}
-          : {
-              [P in OrderFields]: P extends ByFields
-                ? never
-                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
-            }[OrderFields]
-        : 'Error: If you provide "skip", you also need to provide "orderBy"'
-      : ByValid extends True
-      ? {}
-      : {
-          [P in OrderFields]: P extends ByFields
-            ? never
-            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
-        }[OrderFields]
-    >(args: SubsetIntersection<T, RouteOrdersGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRouteOrdersGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
-  /**
-   * Fields of the RouteOrders model
-   */
-  readonly fields: RouteOrdersFieldRefs;
-  }
-
-  /**
-   * The delegate class that acts as a "Promise-like" for RouteOrders.
-   * Why is this prefixed with `Prisma__`?
-   * Because we want to prevent naming conflicts as mentioned in
-   * https://github.com/prisma/prisma-client-js/issues/707
-   */
-  export interface Prisma__RouteOrdersClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
-    readonly [Symbol.toStringTag]: "PrismaPromise"
-    route<T extends RouteDefaultArgs<ExtArgs> = {}>(args?: Subset<T, RouteDefaultArgs<ExtArgs>>): Prisma__RouteClient<$Result.GetResult<Prisma.$RoutePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
-    order<T extends OrderDefaultArgs<ExtArgs> = {}>(args?: Subset<T, OrderDefaultArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of which ever callback is executed.
-     */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of the callback.
-     */
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
-    /**
-     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
-     * resolved value cannot be modified from the callback.
-     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
-     * @returns A Promise for the completion of the callback.
-     */
-    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
-  }
-
-
-
-
-  /**
-   * Fields of the RouteOrders model
-   */
-  interface RouteOrdersFieldRefs {
-    readonly id: FieldRef<"RouteOrders", 'String'>
-    readonly route_id: FieldRef<"RouteOrders", 'String'>
-    readonly order_id: FieldRef<"RouteOrders", 'String'>
-    readonly created_at: FieldRef<"RouteOrders", 'DateTime'>
-    readonly updated_at: FieldRef<"RouteOrders", 'DateTime'>
-  }
-    
-
-  // Custom InputTypes
-  /**
-   * RouteOrders findUnique
-   */
-  export type RouteOrdersFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * Filter, which RouteOrders to fetch.
-     */
-    where: RouteOrdersWhereUniqueInput
-  }
-
-  /**
-   * RouteOrders findUniqueOrThrow
-   */
-  export type RouteOrdersFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * Filter, which RouteOrders to fetch.
-     */
-    where: RouteOrdersWhereUniqueInput
-  }
-
-  /**
-   * RouteOrders findFirst
-   */
-  export type RouteOrdersFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * Filter, which RouteOrders to fetch.
-     */
-    where?: RouteOrdersWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of RouteOrders to fetch.
-     */
-    orderBy?: RouteOrdersOrderByWithRelationInput | RouteOrdersOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the position for searching for RouteOrders.
-     */
-    cursor?: RouteOrdersWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` RouteOrders from the position of the cursor.
-     */
-    take?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Skip the first `n` RouteOrders.
-     */
-    skip?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
-     * 
-     * Filter by unique combinations of RouteOrders.
-     */
-    distinct?: RouteOrdersScalarFieldEnum | RouteOrdersScalarFieldEnum[]
-  }
-
-  /**
-   * RouteOrders findFirstOrThrow
-   */
-  export type RouteOrdersFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * Filter, which RouteOrders to fetch.
-     */
-    where?: RouteOrdersWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of RouteOrders to fetch.
-     */
-    orderBy?: RouteOrdersOrderByWithRelationInput | RouteOrdersOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the position for searching for RouteOrders.
-     */
-    cursor?: RouteOrdersWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` RouteOrders from the position of the cursor.
-     */
-    take?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Skip the first `n` RouteOrders.
-     */
-    skip?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
-     * 
-     * Filter by unique combinations of RouteOrders.
-     */
-    distinct?: RouteOrdersScalarFieldEnum | RouteOrdersScalarFieldEnum[]
-  }
-
-  /**
-   * RouteOrders findMany
-   */
-  export type RouteOrdersFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * Filter, which RouteOrders to fetch.
-     */
-    where?: RouteOrdersWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of RouteOrders to fetch.
-     */
-    orderBy?: RouteOrdersOrderByWithRelationInput | RouteOrdersOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the position for listing RouteOrders.
-     */
-    cursor?: RouteOrdersWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` RouteOrders from the position of the cursor.
-     */
-    take?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Skip the first `n` RouteOrders.
-     */
-    skip?: number
-    distinct?: RouteOrdersScalarFieldEnum | RouteOrdersScalarFieldEnum[]
-  }
-
-  /**
-   * RouteOrders create
-   */
-  export type RouteOrdersCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * The data needed to create a RouteOrders.
-     */
-    data: XOR<RouteOrdersCreateInput, RouteOrdersUncheckedCreateInput>
-  }
-
-  /**
-   * RouteOrders createMany
-   */
-  export type RouteOrdersCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * The data used to create many RouteOrders.
-     */
-    data: RouteOrdersCreateManyInput | RouteOrdersCreateManyInput[]
-    skipDuplicates?: boolean
-  }
-
-  /**
-   * RouteOrders createManyAndReturn
-   */
-  export type RouteOrdersCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelectCreateManyAndReturn<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * The data used to create many RouteOrders.
-     */
-    data: RouteOrdersCreateManyInput | RouteOrdersCreateManyInput[]
-    skipDuplicates?: boolean
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersIncludeCreateManyAndReturn<ExtArgs> | null
-  }
-
-  /**
-   * RouteOrders update
-   */
-  export type RouteOrdersUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * The data needed to update a RouteOrders.
-     */
-    data: XOR<RouteOrdersUpdateInput, RouteOrdersUncheckedUpdateInput>
-    /**
-     * Choose, which RouteOrders to update.
-     */
-    where: RouteOrdersWhereUniqueInput
-  }
-
-  /**
-   * RouteOrders updateMany
-   */
-  export type RouteOrdersUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * The data used to update RouteOrders.
-     */
-    data: XOR<RouteOrdersUpdateManyMutationInput, RouteOrdersUncheckedUpdateManyInput>
-    /**
-     * Filter which RouteOrders to update
-     */
-    where?: RouteOrdersWhereInput
-    /**
-     * Limit how many RouteOrders to update.
-     */
-    limit?: number
-  }
-
-  /**
-   * RouteOrders updateManyAndReturn
-   */
-  export type RouteOrdersUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelectUpdateManyAndReturn<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * The data used to update RouteOrders.
-     */
-    data: XOR<RouteOrdersUpdateManyMutationInput, RouteOrdersUncheckedUpdateManyInput>
-    /**
-     * Filter which RouteOrders to update
-     */
-    where?: RouteOrdersWhereInput
-    /**
-     * Limit how many RouteOrders to update.
-     */
-    limit?: number
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersIncludeUpdateManyAndReturn<ExtArgs> | null
-  }
-
-  /**
-   * RouteOrders upsert
-   */
-  export type RouteOrdersUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * The filter to search for the RouteOrders to update in case it exists.
-     */
-    where: RouteOrdersWhereUniqueInput
-    /**
-     * In case the RouteOrders found by the `where` argument doesn't exist, create a new RouteOrders with this data.
-     */
-    create: XOR<RouteOrdersCreateInput, RouteOrdersUncheckedCreateInput>
-    /**
-     * In case the RouteOrders was found with the provided `where` argument, update it with this data.
-     */
-    update: XOR<RouteOrdersUpdateInput, RouteOrdersUncheckedUpdateInput>
-  }
-
-  /**
-   * RouteOrders delete
-   */
-  export type RouteOrdersDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-    /**
-     * Filter which RouteOrders to delete.
-     */
-    where: RouteOrdersWhereUniqueInput
-  }
-
-  /**
-   * RouteOrders deleteMany
-   */
-  export type RouteOrdersDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Filter which RouteOrders to delete
-     */
-    where?: RouteOrdersWhereInput
-    /**
-     * Limit how many RouteOrders to delete.
-     */
-    limit?: number
-  }
-
-  /**
-   * RouteOrders without action
-   */
-  export type RouteOrdersDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the RouteOrders
-     */
-    select?: RouteOrdersSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the RouteOrders
-     */
-    omit?: RouteOrdersOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: RouteOrdersInclude<ExtArgs> | null
-  }
-
-
-  /**
-   * Model Address
-   */
-
-  export type AggregateAddress = {
-    _count: AddressCountAggregateOutputType | null
-    _avg: AddressAvgAggregateOutputType | null
-    _sum: AddressSumAggregateOutputType | null
-    _min: AddressMinAggregateOutputType | null
-    _max: AddressMaxAggregateOutputType | null
-  }
-
-  export type AddressAvgAggregateOutputType = {
-    sequence: number | null
-    latitude: number | null
-    longitude: number | null
-  }
-
-  export type AddressSumAggregateOutputType = {
-    sequence: number | null
-    latitude: number | null
-    longitude: number | null
-  }
-
-  export type AddressMinAggregateOutputType = {
-    id: string | null
-    address_type: $Enums.AddressType | null
-    sequence: number | null
-    title: string | null
-    address_line1: string | null
-    address_line2: string | null
-    apartment: string | null
-    city: string | null
-    state: string | null
-    postal_code: string | null
-    country: string | null
-    latitude: number | null
-    longitude: number | null
-    route_id: string | null
-    created_at: Date | null
-    updated_at: Date | null
-  }
-
-  export type AddressMaxAggregateOutputType = {
-    id: string | null
-    address_type: $Enums.AddressType | null
-    sequence: number | null
-    title: string | null
-    address_line1: string | null
-    address_line2: string | null
-    apartment: string | null
-    city: string | null
-    state: string | null
-    postal_code: string | null
-    country: string | null
-    latitude: number | null
-    longitude: number | null
-    route_id: string | null
-    created_at: Date | null
-    updated_at: Date | null
-  }
-
-  export type AddressCountAggregateOutputType = {
-    id: number
-    address_type: number
-    sequence: number
-    title: number
-    address_line1: number
-    address_line2: number
-    apartment: number
-    city: number
-    state: number
-    postal_code: number
-    country: number
-    latitude: number
-    longitude: number
-    google_address: number
-    route_id: number
-    created_at: number
-    updated_at: number
-    _all: number
-  }
-
-
-  export type AddressAvgAggregateInputType = {
-    sequence?: true
-    latitude?: true
-    longitude?: true
-  }
-
-  export type AddressSumAggregateInputType = {
-    sequence?: true
-    latitude?: true
-    longitude?: true
-  }
-
-  export type AddressMinAggregateInputType = {
-    id?: true
-    address_type?: true
-    sequence?: true
-    title?: true
-    address_line1?: true
-    address_line2?: true
-    apartment?: true
-    city?: true
-    state?: true
-    postal_code?: true
-    country?: true
-    latitude?: true
-    longitude?: true
-    route_id?: true
-    created_at?: true
-    updated_at?: true
-  }
-
-  export type AddressMaxAggregateInputType = {
-    id?: true
-    address_type?: true
-    sequence?: true
-    title?: true
-    address_line1?: true
-    address_line2?: true
-    apartment?: true
-    city?: true
-    state?: true
-    postal_code?: true
-    country?: true
-    latitude?: true
-    longitude?: true
-    route_id?: true
-    created_at?: true
-    updated_at?: true
-  }
-
-  export type AddressCountAggregateInputType = {
-    id?: true
-    address_type?: true
-    sequence?: true
-    title?: true
-    address_line1?: true
-    address_line2?: true
-    apartment?: true
-    city?: true
-    state?: true
-    postal_code?: true
-    country?: true
-    latitude?: true
-    longitude?: true
-    google_address?: true
-    route_id?: true
-    created_at?: true
-    updated_at?: true
-    _all?: true
-  }
-
-  export type AddressAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Filter which Address to aggregate.
-     */
-    where?: AddressWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of Addresses to fetch.
-     */
-    orderBy?: AddressOrderByWithRelationInput | AddressOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the start position
-     */
-    cursor?: AddressWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` Addresses from the position of the cursor.
-     */
-    take?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Skip the first `n` Addresses.
-     */
-    skip?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Count returned Addresses
-    **/
-    _count?: true | AddressCountAggregateInputType
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Select which fields to average
-    **/
-    _avg?: AddressAvgAggregateInputType
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Select which fields to sum
-    **/
-    _sum?: AddressSumAggregateInputType
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Select which fields to find the minimum value
-    **/
-    _min?: AddressMinAggregateInputType
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Select which fields to find the maximum value
-    **/
-    _max?: AddressMaxAggregateInputType
+    _max?: AddressMaxAggregateInputType
   }
 
   export type GetAddressAggregateType<T extends AddressAggregateArgs> = {
@@ -23053,12 +21873,12 @@ export namespace Prisma {
 
   export const RouteScalarFieldEnum: {
     id: 'id',
+    order_id: 'order_id',
     driver_id: 'driver_id',
     vehicle_id: 'vehicle_id',
     status: 'status',
     started_at: 'started_at',
     completed_at: 'completed_at',
-    type_of_route: 'type_of_route',
     created_at: 'created_at',
     updated_at: 'updated_at'
   };
@@ -23077,17 +21897,6 @@ export namespace Prisma {
   export type RouteHandlingUnitScalarFieldEnum = (typeof RouteHandlingUnitScalarFieldEnum)[keyof typeof RouteHandlingUnitScalarFieldEnum]
 
 
-  export const RouteOrdersScalarFieldEnum: {
-    id: 'id',
-    route_id: 'route_id',
-    order_id: 'order_id',
-    created_at: 'created_at',
-    updated_at: 'updated_at'
-  };
-
-  export type RouteOrdersScalarFieldEnum = (typeof RouteOrdersScalarFieldEnum)[keyof typeof RouteOrdersScalarFieldEnum]
-
-
   export const AddressScalarFieldEnum: {
     id: 'id',
     address_type: 'address_type',
@@ -23355,20 +22164,6 @@ export namespace Prisma {
    */
   export type ListEnumVehicleSizeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'VehicleSize[]'>
     
-
-
-  /**
-   * Reference to a field of type 'TypeOfRoutes'
-   */
-  export type EnumTypeOfRoutesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TypeOfRoutes'>
-    
-
-
-  /**
-   * Reference to a field of type 'TypeOfRoutes[]'
-   */
-  export type ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TypeOfRoutes[]'>
-    
   /**
    * Deep Input Types
    */
@@ -23661,7 +22456,7 @@ export namespace Prisma {
     updated_at?: DateTimeFilter<"Order"> | Date | string
     shipper?: XOR<ClientNullableScalarRelationFilter, ClientWhereInput> | null
     handling_units?: HandlingUnitListRelationFilter
-    route_orders?: RouteOrdersListRelationFilter
+    routes?: RouteListRelationFilter
   }
 
   export type OrderOrderByWithRelationInput = {
@@ -23674,7 +22469,7 @@ export namespace Prisma {
     updated_at?: SortOrder
     shipper?: ClientOrderByWithRelationInput
     handling_units?: HandlingUnitOrderByRelationAggregateInput
-    route_orders?: RouteOrdersOrderByRelationAggregateInput
+    routes?: RouteOrderByRelationAggregateInput
   }
 
   export type OrderWhereUniqueInput = Prisma.AtLeast<{
@@ -23690,7 +22485,7 @@ export namespace Prisma {
     updated_at?: DateTimeFilter<"Order"> | Date | string
     shipper?: XOR<ClientNullableScalarRelationFilter, ClientWhereInput> | null
     handling_units?: HandlingUnitListRelationFilter
-    route_orders?: RouteOrdersListRelationFilter
+    routes?: RouteListRelationFilter
   }, "id">
 
   export type OrderOrderByWithAggregationInput = {
@@ -24414,35 +23209,35 @@ export namespace Prisma {
     OR?: RouteWhereInput[]
     NOT?: RouteWhereInput | RouteWhereInput[]
     id?: UuidFilter<"Route"> | string
+    order_id?: UuidNullableFilter<"Route"> | string | null
     driver_id?: UuidNullableFilter<"Route"> | string | null
     vehicle_id?: UuidNullableFilter<"Route"> | string | null
     status?: EnumRouteStatusFilter<"Route"> | $Enums.RouteStatus
     started_at?: DateTimeNullableFilter<"Route"> | Date | string | null
     completed_at?: DateTimeNullableFilter<"Route"> | Date | string | null
-    type_of_route?: EnumTypeOfRoutesNullableFilter<"Route"> | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFilter<"Route"> | Date | string
     updated_at?: DateTimeFilter<"Route"> | Date | string
+    order?: XOR<OrderNullableScalarRelationFilter, OrderWhereInput> | null
     driver?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
     vehicle?: XOR<VehicleNullableScalarRelationFilter, VehicleWhereInput> | null
     route_handling_units?: RouteHandlingUnitListRelationFilter
-    route_orders?: RouteOrdersListRelationFilter
     addresses?: AddressListRelationFilter
   }
 
   export type RouteOrderByWithRelationInput = {
     id?: SortOrder
+    order_id?: SortOrderInput | SortOrder
     driver_id?: SortOrderInput | SortOrder
     vehicle_id?: SortOrderInput | SortOrder
     status?: SortOrder
     started_at?: SortOrderInput | SortOrder
     completed_at?: SortOrderInput | SortOrder
-    type_of_route?: SortOrderInput | SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
+    order?: OrderOrderByWithRelationInput
     driver?: UserOrderByWithRelationInput
     vehicle?: VehicleOrderByWithRelationInput
     route_handling_units?: RouteHandlingUnitOrderByRelationAggregateInput
-    route_orders?: RouteOrdersOrderByRelationAggregateInput
     addresses?: AddressOrderByRelationAggregateInput
   }
 
@@ -24451,29 +23246,29 @@ export namespace Prisma {
     AND?: RouteWhereInput | RouteWhereInput[]
     OR?: RouteWhereInput[]
     NOT?: RouteWhereInput | RouteWhereInput[]
+    order_id?: UuidNullableFilter<"Route"> | string | null
     driver_id?: UuidNullableFilter<"Route"> | string | null
     vehicle_id?: UuidNullableFilter<"Route"> | string | null
     status?: EnumRouteStatusFilter<"Route"> | $Enums.RouteStatus
     started_at?: DateTimeNullableFilter<"Route"> | Date | string | null
     completed_at?: DateTimeNullableFilter<"Route"> | Date | string | null
-    type_of_route?: EnumTypeOfRoutesNullableFilter<"Route"> | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFilter<"Route"> | Date | string
     updated_at?: DateTimeFilter<"Route"> | Date | string
+    order?: XOR<OrderNullableScalarRelationFilter, OrderWhereInput> | null
     driver?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
     vehicle?: XOR<VehicleNullableScalarRelationFilter, VehicleWhereInput> | null
     route_handling_units?: RouteHandlingUnitListRelationFilter
-    route_orders?: RouteOrdersListRelationFilter
     addresses?: AddressListRelationFilter
   }, "id">
 
   export type RouteOrderByWithAggregationInput = {
     id?: SortOrder
+    order_id?: SortOrderInput | SortOrder
     driver_id?: SortOrderInput | SortOrder
     vehicle_id?: SortOrderInput | SortOrder
     status?: SortOrder
     started_at?: SortOrderInput | SortOrder
     completed_at?: SortOrderInput | SortOrder
-    type_of_route?: SortOrderInput | SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
     _count?: RouteCountOrderByAggregateInput
@@ -24486,12 +23281,12 @@ export namespace Prisma {
     OR?: RouteScalarWhereWithAggregatesInput[]
     NOT?: RouteScalarWhereWithAggregatesInput | RouteScalarWhereWithAggregatesInput[]
     id?: UuidWithAggregatesFilter<"Route"> | string
+    order_id?: UuidNullableWithAggregatesFilter<"Route"> | string | null
     driver_id?: UuidNullableWithAggregatesFilter<"Route"> | string | null
     vehicle_id?: UuidNullableWithAggregatesFilter<"Route"> | string | null
     status?: EnumRouteStatusWithAggregatesFilter<"Route"> | $Enums.RouteStatus
     started_at?: DateTimeNullableWithAggregatesFilter<"Route"> | Date | string | null
     completed_at?: DateTimeNullableWithAggregatesFilter<"Route"> | Date | string | null
-    type_of_route?: EnumTypeOfRoutesNullableWithAggregatesFilter<"Route"> | $Enums.TypeOfRoutes | null
     created_at?: DateTimeWithAggregatesFilter<"Route"> | Date | string
     updated_at?: DateTimeWithAggregatesFilter<"Route"> | Date | string
   }
@@ -24554,64 +23349,6 @@ export namespace Prisma {
     updated_at?: DateTimeWithAggregatesFilter<"RouteHandlingUnit"> | Date | string
   }
 
-  export type RouteOrdersWhereInput = {
-    AND?: RouteOrdersWhereInput | RouteOrdersWhereInput[]
-    OR?: RouteOrdersWhereInput[]
-    NOT?: RouteOrdersWhereInput | RouteOrdersWhereInput[]
-    id?: UuidFilter<"RouteOrders"> | string
-    route_id?: UuidFilter<"RouteOrders"> | string
-    order_id?: UuidFilter<"RouteOrders"> | string
-    created_at?: DateTimeFilter<"RouteOrders"> | Date | string
-    updated_at?: DateTimeFilter<"RouteOrders"> | Date | string
-    route?: XOR<RouteScalarRelationFilter, RouteWhereInput>
-    order?: XOR<OrderScalarRelationFilter, OrderWhereInput>
-  }
-
-  export type RouteOrdersOrderByWithRelationInput = {
-    id?: SortOrder
-    route_id?: SortOrder
-    order_id?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-    route?: RouteOrderByWithRelationInput
-    order?: OrderOrderByWithRelationInput
-  }
-
-  export type RouteOrdersWhereUniqueInput = Prisma.AtLeast<{
-    id?: string
-    AND?: RouteOrdersWhereInput | RouteOrdersWhereInput[]
-    OR?: RouteOrdersWhereInput[]
-    NOT?: RouteOrdersWhereInput | RouteOrdersWhereInput[]
-    route_id?: UuidFilter<"RouteOrders"> | string
-    order_id?: UuidFilter<"RouteOrders"> | string
-    created_at?: DateTimeFilter<"RouteOrders"> | Date | string
-    updated_at?: DateTimeFilter<"RouteOrders"> | Date | string
-    route?: XOR<RouteScalarRelationFilter, RouteWhereInput>
-    order?: XOR<OrderScalarRelationFilter, OrderWhereInput>
-  }, "id">
-
-  export type RouteOrdersOrderByWithAggregationInput = {
-    id?: SortOrder
-    route_id?: SortOrder
-    order_id?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-    _count?: RouteOrdersCountOrderByAggregateInput
-    _max?: RouteOrdersMaxOrderByAggregateInput
-    _min?: RouteOrdersMinOrderByAggregateInput
-  }
-
-  export type RouteOrdersScalarWhereWithAggregatesInput = {
-    AND?: RouteOrdersScalarWhereWithAggregatesInput | RouteOrdersScalarWhereWithAggregatesInput[]
-    OR?: RouteOrdersScalarWhereWithAggregatesInput[]
-    NOT?: RouteOrdersScalarWhereWithAggregatesInput | RouteOrdersScalarWhereWithAggregatesInput[]
-    id?: UuidWithAggregatesFilter<"RouteOrders"> | string
-    route_id?: UuidWithAggregatesFilter<"RouteOrders"> | string
-    order_id?: UuidWithAggregatesFilter<"RouteOrders"> | string
-    created_at?: DateTimeWithAggregatesFilter<"RouteOrders"> | Date | string
-    updated_at?: DateTimeWithAggregatesFilter<"RouteOrders"> | Date | string
-  }
-
   export type AddressWhereInput = {
     AND?: AddressWhereInput | AddressWhereInput[]
     OR?: AddressWhereInput[]
@@ -25113,7 +23850,7 @@ export namespace Prisma {
     updated_at?: Date | string
     shipper?: ClientCreateNestedOneWithoutOrders_as_shipperInput
     handling_units?: HandlingUnitCreateNestedManyWithoutOrderInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutOrderInput
+    routes?: RouteCreateNestedManyWithoutOrderInput
   }
 
   export type OrderUncheckedCreateInput = {
@@ -25125,7 +23862,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     handling_units?: HandlingUnitUncheckedCreateNestedManyWithoutOrderInput
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutOrderInput
+    routes?: RouteUncheckedCreateNestedManyWithoutOrderInput
   }
 
   export type OrderUpdateInput = {
@@ -25137,7 +23874,7 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     shipper?: ClientUpdateOneWithoutOrders_as_shipperNestedInput
     handling_units?: HandlingUnitUpdateManyWithoutOrderNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutOrderNestedInput
+    routes?: RouteUpdateManyWithoutOrderNestedInput
   }
 
   export type OrderUncheckedUpdateInput = {
@@ -25149,7 +23886,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     handling_units?: HandlingUnitUncheckedUpdateManyWithoutOrderNestedInput
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutOrderNestedInput
+    routes?: RouteUncheckedUpdateManyWithoutOrderNestedInput
   }
 
   export type OrderCreateManyInput = {
@@ -25960,28 +24697,26 @@ export namespace Prisma {
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
+    order?: OrderCreateNestedOneWithoutRoutesInput
     driver?: UserCreateNestedOneWithoutRoutesInput
     vehicle?: VehicleCreateNestedOneWithoutRoutesInput
     route_handling_units?: RouteHandlingUnitCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutRouteInput
     addresses?: AddressCreateNestedManyWithoutRouteInput
   }
 
   export type RouteUncheckedCreateInput = {
     id?: string
+    order_id?: string | null
     driver_id?: string | null
     vehicle_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
     route_handling_units?: RouteHandlingUnitUncheckedCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutRouteInput
     addresses?: AddressUncheckedCreateNestedManyWithoutRouteInput
   }
 
@@ -25990,39 +24725,37 @@ export namespace Prisma {
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    order?: OrderUpdateOneWithoutRoutesNestedInput
     driver?: UserUpdateOneWithoutRoutesNestedInput
     vehicle?: VehicleUpdateOneWithoutRoutesNestedInput
     route_handling_units?: RouteHandlingUnitUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutRouteNestedInput
     addresses?: AddressUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteUncheckedUpdateInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     driver_id?: NullableStringFieldUpdateOperationsInput | string | null
     vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     route_handling_units?: RouteHandlingUnitUncheckedUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutRouteNestedInput
     addresses?: AddressUncheckedUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteCreateManyInput = {
     id?: string
+    order_id?: string | null
     driver_id?: string | null
     vehicle_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
   }
@@ -26032,19 +24765,18 @@ export namespace Prisma {
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
   export type RouteUncheckedUpdateManyInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     driver_id?: NullableStringFieldUpdateOperationsInput | string | null
     vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -26103,60 +24835,6 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
-  export type RouteOrdersCreateInput = {
-    id?: string
-    created_at?: Date | string
-    updated_at?: Date | string
-    route: RouteCreateNestedOneWithoutRoute_ordersInput
-    order: OrderCreateNestedOneWithoutRoute_ordersInput
-  }
-
-  export type RouteOrdersUncheckedCreateInput = {
-    id?: string
-    route_id: string
-    order_id: string
-    created_at?: Date | string
-    updated_at?: Date | string
-  }
-
-  export type RouteOrdersUpdateInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    route?: RouteUpdateOneRequiredWithoutRoute_ordersNestedInput
-    order?: OrderUpdateOneRequiredWithoutRoute_ordersNestedInput
-  }
-
-  export type RouteOrdersUncheckedUpdateInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    route_id?: StringFieldUpdateOperationsInput | string
-    order_id?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-  }
-
-  export type RouteOrdersCreateManyInput = {
-    id?: string
-    route_id: string
-    order_id: string
-    created_at?: Date | string
-    updated_at?: Date | string
-  }
-
-  export type RouteOrdersUpdateManyMutationInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-  }
-
-  export type RouteOrdersUncheckedUpdateManyInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    route_id?: StringFieldUpdateOperationsInput | string
-    order_id?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-  }
-
   export type AddressCreateInput = {
     id?: string
     address_type?: $Enums.AddressType
@@ -26785,13 +25463,13 @@ export namespace Prisma {
     isNot?: ClientWhereInput | null
   }
 
-  export type RouteOrdersListRelationFilter = {
-    every?: RouteOrdersWhereInput
-    some?: RouteOrdersWhereInput
-    none?: RouteOrdersWhereInput
+  export type RouteListRelationFilter = {
+    every?: RouteWhereInput
+    some?: RouteWhereInput
+    none?: RouteWhereInput
   }
 
-  export type RouteOrdersOrderByRelationAggregateInput = {
+  export type RouteOrderByRelationAggregateInput = {
     _count?: SortOrder
   }
 
@@ -27132,22 +25810,12 @@ export namespace Prisma {
     not?: NestedEnumRolesFilter<$PrismaModel> | $Enums.Roles
   }
 
-  export type RouteListRelationFilter = {
-    every?: RouteWhereInput
-    some?: RouteWhereInput
-    none?: RouteWhereInput
-  }
-
   export type SessionListRelationFilter = {
     every?: SessionWhereInput
     some?: SessionWhereInput
     none?: SessionWhereInput
   }
 
-  export type RouteOrderByRelationAggregateInput = {
-    _count?: SortOrder
-  }
-
   export type SessionOrderByRelationAggregateInput = {
     _count?: SortOrder
   }
@@ -27491,11 +26159,9 @@ export namespace Prisma {
     _max?: NestedEnumVehicleSizeNullableFilter<$PrismaModel>
   }
 
-  export type EnumTypeOfRoutesNullableFilter<$PrismaModel = never> = {
-    equals?: $Enums.TypeOfRoutes | EnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    in?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    notIn?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    not?: NestedEnumTypeOfRoutesNullableFilter<$PrismaModel> | $Enums.TypeOfRoutes | null
+  export type OrderNullableScalarRelationFilter = {
+    is?: OrderWhereInput | null
+    isNot?: OrderWhereInput | null
   }
 
   export type UserNullableScalarRelationFilter = {
@@ -27520,50 +26186,40 @@ export namespace Prisma {
 
   export type RouteCountOrderByAggregateInput = {
     id?: SortOrder
+    order_id?: SortOrder
     driver_id?: SortOrder
     vehicle_id?: SortOrder
     status?: SortOrder
     started_at?: SortOrder
     completed_at?: SortOrder
-    type_of_route?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
   }
 
   export type RouteMaxOrderByAggregateInput = {
     id?: SortOrder
+    order_id?: SortOrder
     driver_id?: SortOrder
     vehicle_id?: SortOrder
     status?: SortOrder
     started_at?: SortOrder
     completed_at?: SortOrder
-    type_of_route?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
   }
 
   export type RouteMinOrderByAggregateInput = {
     id?: SortOrder
+    order_id?: SortOrder
     driver_id?: SortOrder
     vehicle_id?: SortOrder
     status?: SortOrder
     started_at?: SortOrder
     completed_at?: SortOrder
-    type_of_route?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
   }
 
-  export type EnumTypeOfRoutesNullableWithAggregatesFilter<$PrismaModel = never> = {
-    equals?: $Enums.TypeOfRoutes | EnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    in?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    notIn?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    not?: NestedEnumTypeOfRoutesNullableWithAggregatesFilter<$PrismaModel> | $Enums.TypeOfRoutes | null
-    _count?: NestedIntNullableFilter<$PrismaModel>
-    _min?: NestedEnumTypeOfRoutesNullableFilter<$PrismaModel>
-    _max?: NestedEnumTypeOfRoutesNullableFilter<$PrismaModel>
-  }
-
   export type RouteScalarRelationFilter = {
     is?: RouteWhereInput
     isNot?: RouteWhereInput
@@ -27598,30 +26254,6 @@ export namespace Prisma {
     updated_at?: SortOrder
   }
 
-  export type RouteOrdersCountOrderByAggregateInput = {
-    id?: SortOrder
-    route_id?: SortOrder
-    order_id?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-  }
-
-  export type RouteOrdersMaxOrderByAggregateInput = {
-    id?: SortOrder
-    route_id?: SortOrder
-    order_id?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-  }
-
-  export type RouteOrdersMinOrderByAggregateInput = {
-    id?: SortOrder
-    route_id?: SortOrder
-    order_id?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-  }
-
   export type RouteNullableScalarRelationFilter = {
     is?: RouteWhereInput | null
     isNot?: RouteWhereInput | null
@@ -27979,11 +26611,11 @@ export namespace Prisma {
     connect?: HandlingUnitWhereUniqueInput | HandlingUnitWhereUniqueInput[]
   }
 
-  export type RouteOrdersCreateNestedManyWithoutOrderInput = {
-    create?: XOR<RouteOrdersCreateWithoutOrderInput, RouteOrdersUncheckedCreateWithoutOrderInput> | RouteOrdersCreateWithoutOrderInput[] | RouteOrdersUncheckedCreateWithoutOrderInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutOrderInput | RouteOrdersCreateOrConnectWithoutOrderInput[]
-    createMany?: RouteOrdersCreateManyOrderInputEnvelope
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
+  export type RouteCreateNestedManyWithoutOrderInput = {
+    create?: XOR<RouteCreateWithoutOrderInput, RouteUncheckedCreateWithoutOrderInput> | RouteCreateWithoutOrderInput[] | RouteUncheckedCreateWithoutOrderInput[]
+    connectOrCreate?: RouteCreateOrConnectWithoutOrderInput | RouteCreateOrConnectWithoutOrderInput[]
+    createMany?: RouteCreateManyOrderInputEnvelope
+    connect?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
   }
 
   export type HandlingUnitUncheckedCreateNestedManyWithoutOrderInput = {
@@ -27993,11 +26625,11 @@ export namespace Prisma {
     connect?: HandlingUnitWhereUniqueInput | HandlingUnitWhereUniqueInput[]
   }
 
-  export type RouteOrdersUncheckedCreateNestedManyWithoutOrderInput = {
-    create?: XOR<RouteOrdersCreateWithoutOrderInput, RouteOrdersUncheckedCreateWithoutOrderInput> | RouteOrdersCreateWithoutOrderInput[] | RouteOrdersUncheckedCreateWithoutOrderInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutOrderInput | RouteOrdersCreateOrConnectWithoutOrderInput[]
-    createMany?: RouteOrdersCreateManyOrderInputEnvelope
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
+  export type RouteUncheckedCreateNestedManyWithoutOrderInput = {
+    create?: XOR<RouteCreateWithoutOrderInput, RouteUncheckedCreateWithoutOrderInput> | RouteCreateWithoutOrderInput[] | RouteUncheckedCreateWithoutOrderInput[]
+    connectOrCreate?: RouteCreateOrConnectWithoutOrderInput | RouteCreateOrConnectWithoutOrderInput[]
+    createMany?: RouteCreateManyOrderInputEnvelope
+    connect?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
   }
 
   export type EnumRouteStatusFieldUpdateOperationsInput = {
@@ -28028,18 +26660,18 @@ export namespace Prisma {
     deleteMany?: HandlingUnitScalarWhereInput | HandlingUnitScalarWhereInput[]
   }
 
-  export type RouteOrdersUpdateManyWithoutOrderNestedInput = {
-    create?: XOR<RouteOrdersCreateWithoutOrderInput, RouteOrdersUncheckedCreateWithoutOrderInput> | RouteOrdersCreateWithoutOrderInput[] | RouteOrdersUncheckedCreateWithoutOrderInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutOrderInput | RouteOrdersCreateOrConnectWithoutOrderInput[]
-    upsert?: RouteOrdersUpsertWithWhereUniqueWithoutOrderInput | RouteOrdersUpsertWithWhereUniqueWithoutOrderInput[]
-    createMany?: RouteOrdersCreateManyOrderInputEnvelope
-    set?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    disconnect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    delete?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    update?: RouteOrdersUpdateWithWhereUniqueWithoutOrderInput | RouteOrdersUpdateWithWhereUniqueWithoutOrderInput[]
-    updateMany?: RouteOrdersUpdateManyWithWhereWithoutOrderInput | RouteOrdersUpdateManyWithWhereWithoutOrderInput[]
-    deleteMany?: RouteOrdersScalarWhereInput | RouteOrdersScalarWhereInput[]
+  export type RouteUpdateManyWithoutOrderNestedInput = {
+    create?: XOR<RouteCreateWithoutOrderInput, RouteUncheckedCreateWithoutOrderInput> | RouteCreateWithoutOrderInput[] | RouteUncheckedCreateWithoutOrderInput[]
+    connectOrCreate?: RouteCreateOrConnectWithoutOrderInput | RouteCreateOrConnectWithoutOrderInput[]
+    upsert?: RouteUpsertWithWhereUniqueWithoutOrderInput | RouteUpsertWithWhereUniqueWithoutOrderInput[]
+    createMany?: RouteCreateManyOrderInputEnvelope
+    set?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    disconnect?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    delete?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    connect?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    update?: RouteUpdateWithWhereUniqueWithoutOrderInput | RouteUpdateWithWhereUniqueWithoutOrderInput[]
+    updateMany?: RouteUpdateManyWithWhereWithoutOrderInput | RouteUpdateManyWithWhereWithoutOrderInput[]
+    deleteMany?: RouteScalarWhereInput | RouteScalarWhereInput[]
   }
 
   export type HandlingUnitUncheckedUpdateManyWithoutOrderNestedInput = {
@@ -28056,18 +26688,18 @@ export namespace Prisma {
     deleteMany?: HandlingUnitScalarWhereInput | HandlingUnitScalarWhereInput[]
   }
 
-  export type RouteOrdersUncheckedUpdateManyWithoutOrderNestedInput = {
-    create?: XOR<RouteOrdersCreateWithoutOrderInput, RouteOrdersUncheckedCreateWithoutOrderInput> | RouteOrdersCreateWithoutOrderInput[] | RouteOrdersUncheckedCreateWithoutOrderInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutOrderInput | RouteOrdersCreateOrConnectWithoutOrderInput[]
-    upsert?: RouteOrdersUpsertWithWhereUniqueWithoutOrderInput | RouteOrdersUpsertWithWhereUniqueWithoutOrderInput[]
-    createMany?: RouteOrdersCreateManyOrderInputEnvelope
-    set?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    disconnect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    delete?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    update?: RouteOrdersUpdateWithWhereUniqueWithoutOrderInput | RouteOrdersUpdateWithWhereUniqueWithoutOrderInput[]
-    updateMany?: RouteOrdersUpdateManyWithWhereWithoutOrderInput | RouteOrdersUpdateManyWithWhereWithoutOrderInput[]
-    deleteMany?: RouteOrdersScalarWhereInput | RouteOrdersScalarWhereInput[]
+  export type RouteUncheckedUpdateManyWithoutOrderNestedInput = {
+    create?: XOR<RouteCreateWithoutOrderInput, RouteUncheckedCreateWithoutOrderInput> | RouteCreateWithoutOrderInput[] | RouteUncheckedCreateWithoutOrderInput[]
+    connectOrCreate?: RouteCreateOrConnectWithoutOrderInput | RouteCreateOrConnectWithoutOrderInput[]
+    upsert?: RouteUpsertWithWhereUniqueWithoutOrderInput | RouteUpsertWithWhereUniqueWithoutOrderInput[]
+    createMany?: RouteCreateManyOrderInputEnvelope
+    set?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    disconnect?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    delete?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    connect?: RouteWhereUniqueInput | RouteWhereUniqueInput[]
+    update?: RouteUpdateWithWhereUniqueWithoutOrderInput | RouteUpdateWithWhereUniqueWithoutOrderInput[]
+    updateMany?: RouteUpdateManyWithWhereWithoutOrderInput | RouteUpdateManyWithWhereWithoutOrderInput[]
+    deleteMany?: RouteScalarWhereInput | RouteScalarWhereInput[]
   }
 
   export type ClientCreateNestedManyWithoutCompanyInput = {
@@ -28752,6 +27384,12 @@ export namespace Prisma {
     deleteMany?: RouteScalarWhereInput | RouteScalarWhereInput[]
   }
 
+  export type OrderCreateNestedOneWithoutRoutesInput = {
+    create?: XOR<OrderCreateWithoutRoutesInput, OrderUncheckedCreateWithoutRoutesInput>
+    connectOrCreate?: OrderCreateOrConnectWithoutRoutesInput
+    connect?: OrderWhereUniqueInput
+  }
+
   export type UserCreateNestedOneWithoutRoutesInput = {
     create?: XOR<UserCreateWithoutRoutesInput, UserUncheckedCreateWithoutRoutesInput>
     connectOrCreate?: UserCreateOrConnectWithoutRoutesInput
@@ -28771,13 +27409,6 @@ export namespace Prisma {
     connect?: RouteHandlingUnitWhereUniqueInput | RouteHandlingUnitWhereUniqueInput[]
   }
 
-  export type RouteOrdersCreateNestedManyWithoutRouteInput = {
-    create?: XOR<RouteOrdersCreateWithoutRouteInput, RouteOrdersUncheckedCreateWithoutRouteInput> | RouteOrdersCreateWithoutRouteInput[] | RouteOrdersUncheckedCreateWithoutRouteInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutRouteInput | RouteOrdersCreateOrConnectWithoutRouteInput[]
-    createMany?: RouteOrdersCreateManyRouteInputEnvelope
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-  }
-
   export type AddressCreateNestedManyWithoutRouteInput = {
     create?: XOR<AddressCreateWithoutRouteInput, AddressUncheckedCreateWithoutRouteInput> | AddressCreateWithoutRouteInput[] | AddressUncheckedCreateWithoutRouteInput[]
     connectOrCreate?: AddressCreateOrConnectWithoutRouteInput | AddressCreateOrConnectWithoutRouteInput[]
@@ -28792,13 +27423,6 @@ export namespace Prisma {
     connect?: RouteHandlingUnitWhereUniqueInput | RouteHandlingUnitWhereUniqueInput[]
   }
 
-  export type RouteOrdersUncheckedCreateNestedManyWithoutRouteInput = {
-    create?: XOR<RouteOrdersCreateWithoutRouteInput, RouteOrdersUncheckedCreateWithoutRouteInput> | RouteOrdersCreateWithoutRouteInput[] | RouteOrdersUncheckedCreateWithoutRouteInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutRouteInput | RouteOrdersCreateOrConnectWithoutRouteInput[]
-    createMany?: RouteOrdersCreateManyRouteInputEnvelope
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-  }
-
   export type AddressUncheckedCreateNestedManyWithoutRouteInput = {
     create?: XOR<AddressCreateWithoutRouteInput, AddressUncheckedCreateWithoutRouteInput> | AddressCreateWithoutRouteInput[] | AddressUncheckedCreateWithoutRouteInput[]
     connectOrCreate?: AddressCreateOrConnectWithoutRouteInput | AddressCreateOrConnectWithoutRouteInput[]
@@ -28806,8 +27430,14 @@ export namespace Prisma {
     connect?: AddressWhereUniqueInput | AddressWhereUniqueInput[]
   }
 
-  export type NullableEnumTypeOfRoutesFieldUpdateOperationsInput = {
-    set?: $Enums.TypeOfRoutes | null
+  export type OrderUpdateOneWithoutRoutesNestedInput = {
+    create?: XOR<OrderCreateWithoutRoutesInput, OrderUncheckedCreateWithoutRoutesInput>
+    connectOrCreate?: OrderCreateOrConnectWithoutRoutesInput
+    upsert?: OrderUpsertWithoutRoutesInput
+    disconnect?: OrderWhereInput | boolean
+    delete?: OrderWhereInput | boolean
+    connect?: OrderWhereUniqueInput
+    update?: XOR<XOR<OrderUpdateToOneWithWhereWithoutRoutesInput, OrderUpdateWithoutRoutesInput>, OrderUncheckedUpdateWithoutRoutesInput>
   }
 
   export type UserUpdateOneWithoutRoutesNestedInput = {
@@ -28844,20 +27474,6 @@ export namespace Prisma {
     deleteMany?: RouteHandlingUnitScalarWhereInput | RouteHandlingUnitScalarWhereInput[]
   }
 
-  export type RouteOrdersUpdateManyWithoutRouteNestedInput = {
-    create?: XOR<RouteOrdersCreateWithoutRouteInput, RouteOrdersUncheckedCreateWithoutRouteInput> | RouteOrdersCreateWithoutRouteInput[] | RouteOrdersUncheckedCreateWithoutRouteInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutRouteInput | RouteOrdersCreateOrConnectWithoutRouteInput[]
-    upsert?: RouteOrdersUpsertWithWhereUniqueWithoutRouteInput | RouteOrdersUpsertWithWhereUniqueWithoutRouteInput[]
-    createMany?: RouteOrdersCreateManyRouteInputEnvelope
-    set?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    disconnect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    delete?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    update?: RouteOrdersUpdateWithWhereUniqueWithoutRouteInput | RouteOrdersUpdateWithWhereUniqueWithoutRouteInput[]
-    updateMany?: RouteOrdersUpdateManyWithWhereWithoutRouteInput | RouteOrdersUpdateManyWithWhereWithoutRouteInput[]
-    deleteMany?: RouteOrdersScalarWhereInput | RouteOrdersScalarWhereInput[]
-  }
-
   export type AddressUpdateManyWithoutRouteNestedInput = {
     create?: XOR<AddressCreateWithoutRouteInput, AddressUncheckedCreateWithoutRouteInput> | AddressCreateWithoutRouteInput[] | AddressUncheckedCreateWithoutRouteInput[]
     connectOrCreate?: AddressCreateOrConnectWithoutRouteInput | AddressCreateOrConnectWithoutRouteInput[]
@@ -28886,20 +27502,6 @@ export namespace Prisma {
     deleteMany?: RouteHandlingUnitScalarWhereInput | RouteHandlingUnitScalarWhereInput[]
   }
 
-  export type RouteOrdersUncheckedUpdateManyWithoutRouteNestedInput = {
-    create?: XOR<RouteOrdersCreateWithoutRouteInput, RouteOrdersUncheckedCreateWithoutRouteInput> | RouteOrdersCreateWithoutRouteInput[] | RouteOrdersUncheckedCreateWithoutRouteInput[]
-    connectOrCreate?: RouteOrdersCreateOrConnectWithoutRouteInput | RouteOrdersCreateOrConnectWithoutRouteInput[]
-    upsert?: RouteOrdersUpsertWithWhereUniqueWithoutRouteInput | RouteOrdersUpsertWithWhereUniqueWithoutRouteInput[]
-    createMany?: RouteOrdersCreateManyRouteInputEnvelope
-    set?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    disconnect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    delete?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    connect?: RouteOrdersWhereUniqueInput | RouteOrdersWhereUniqueInput[]
-    update?: RouteOrdersUpdateWithWhereUniqueWithoutRouteInput | RouteOrdersUpdateWithWhereUniqueWithoutRouteInput[]
-    updateMany?: RouteOrdersUpdateManyWithWhereWithoutRouteInput | RouteOrdersUpdateManyWithWhereWithoutRouteInput[]
-    deleteMany?: RouteOrdersScalarWhereInput | RouteOrdersScalarWhereInput[]
-  }
-
   export type AddressUncheckedUpdateManyWithoutRouteNestedInput = {
     create?: XOR<AddressCreateWithoutRouteInput, AddressUncheckedCreateWithoutRouteInput> | AddressCreateWithoutRouteInput[] | AddressUncheckedCreateWithoutRouteInput[]
     connectOrCreate?: AddressCreateOrConnectWithoutRouteInput | AddressCreateOrConnectWithoutRouteInput[]
@@ -28942,34 +27544,6 @@ export namespace Prisma {
     update?: XOR<XOR<HandlingUnitUpdateToOneWithWhereWithoutRoute_handling_unitsInput, HandlingUnitUpdateWithoutRoute_handling_unitsInput>, HandlingUnitUncheckedUpdateWithoutRoute_handling_unitsInput>
   }
 
-  export type RouteCreateNestedOneWithoutRoute_ordersInput = {
-    create?: XOR<RouteCreateWithoutRoute_ordersInput, RouteUncheckedCreateWithoutRoute_ordersInput>
-    connectOrCreate?: RouteCreateOrConnectWithoutRoute_ordersInput
-    connect?: RouteWhereUniqueInput
-  }
-
-  export type OrderCreateNestedOneWithoutRoute_ordersInput = {
-    create?: XOR<OrderCreateWithoutRoute_ordersInput, OrderUncheckedCreateWithoutRoute_ordersInput>
-    connectOrCreate?: OrderCreateOrConnectWithoutRoute_ordersInput
-    connect?: OrderWhereUniqueInput
-  }
-
-  export type RouteUpdateOneRequiredWithoutRoute_ordersNestedInput = {
-    create?: XOR<RouteCreateWithoutRoute_ordersInput, RouteUncheckedCreateWithoutRoute_ordersInput>
-    connectOrCreate?: RouteCreateOrConnectWithoutRoute_ordersInput
-    upsert?: RouteUpsertWithoutRoute_ordersInput
-    connect?: RouteWhereUniqueInput
-    update?: XOR<XOR<RouteUpdateToOneWithWhereWithoutRoute_ordersInput, RouteUpdateWithoutRoute_ordersInput>, RouteUncheckedUpdateWithoutRoute_ordersInput>
-  }
-
-  export type OrderUpdateOneRequiredWithoutRoute_ordersNestedInput = {
-    create?: XOR<OrderCreateWithoutRoute_ordersInput, OrderUncheckedCreateWithoutRoute_ordersInput>
-    connectOrCreate?: OrderCreateOrConnectWithoutRoute_ordersInput
-    upsert?: OrderUpsertWithoutRoute_ordersInput
-    connect?: OrderWhereUniqueInput
-    update?: XOR<XOR<OrderUpdateToOneWithWhereWithoutRoute_ordersInput, OrderUpdateWithoutRoute_ordersInput>, OrderUncheckedUpdateWithoutRoute_ordersInput>
-  }
-
   export type RouteCreateNestedOneWithoutAddressesInput = {
     create?: XOR<RouteCreateWithoutAddressesInput, RouteUncheckedCreateWithoutAddressesInput>
     connectOrCreate?: RouteCreateOrConnectWithoutAddressesInput
@@ -29482,23 +28056,6 @@ export namespace Prisma {
     _max?: NestedEnumVehicleSizeNullableFilter<$PrismaModel>
   }
 
-  export type NestedEnumTypeOfRoutesNullableFilter<$PrismaModel = never> = {
-    equals?: $Enums.TypeOfRoutes | EnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    in?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    notIn?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    not?: NestedEnumTypeOfRoutesNullableFilter<$PrismaModel> | $Enums.TypeOfRoutes | null
-  }
-
-  export type NestedEnumTypeOfRoutesNullableWithAggregatesFilter<$PrismaModel = never> = {
-    equals?: $Enums.TypeOfRoutes | EnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    in?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    notIn?: $Enums.TypeOfRoutes[] | ListEnumTypeOfRoutesFieldRefInput<$PrismaModel> | null
-    not?: NestedEnumTypeOfRoutesNullableWithAggregatesFilter<$PrismaModel> | $Enums.TypeOfRoutes | null
-    _count?: NestedIntNullableFilter<$PrismaModel>
-    _min?: NestedEnumTypeOfRoutesNullableFilter<$PrismaModel>
-    _max?: NestedEnumTypeOfRoutesNullableFilter<$PrismaModel>
-  }
-
   export type companiesCreateWithoutClientsInput = {
     id?: string
     tax_id?: string | null
@@ -29614,7 +28171,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     handling_units?: HandlingUnitCreateNestedManyWithoutOrderInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutOrderInput
+    routes?: RouteCreateNestedManyWithoutOrderInput
   }
 
   export type OrderUncheckedCreateWithoutShipperInput = {
@@ -29625,7 +28182,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     handling_units?: HandlingUnitUncheckedCreateNestedManyWithoutOrderInput
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutOrderInput
+    routes?: RouteUncheckedCreateNestedManyWithoutOrderInput
   }
 
   export type OrderCreateOrConnectWithoutShipperInput = {
@@ -30152,27 +28709,39 @@ export namespace Prisma {
     skipDuplicates?: boolean
   }
 
-  export type RouteOrdersCreateWithoutOrderInput = {
+  export type RouteCreateWithoutOrderInput = {
     id?: string
+    status?: $Enums.RouteStatus
+    started_at?: Date | string | null
+    completed_at?: Date | string | null
     created_at?: Date | string
     updated_at?: Date | string
-    route: RouteCreateNestedOneWithoutRoute_ordersInput
+    driver?: UserCreateNestedOneWithoutRoutesInput
+    vehicle?: VehicleCreateNestedOneWithoutRoutesInput
+    route_handling_units?: RouteHandlingUnitCreateNestedManyWithoutRouteInput
+    addresses?: AddressCreateNestedManyWithoutRouteInput
   }
 
-  export type RouteOrdersUncheckedCreateWithoutOrderInput = {
+  export type RouteUncheckedCreateWithoutOrderInput = {
     id?: string
-    route_id: string
+    driver_id?: string | null
+    vehicle_id?: string | null
+    status?: $Enums.RouteStatus
+    started_at?: Date | string | null
+    completed_at?: Date | string | null
     created_at?: Date | string
     updated_at?: Date | string
+    route_handling_units?: RouteHandlingUnitUncheckedCreateNestedManyWithoutRouteInput
+    addresses?: AddressUncheckedCreateNestedManyWithoutRouteInput
   }
 
-  export type RouteOrdersCreateOrConnectWithoutOrderInput = {
-    where: RouteOrdersWhereUniqueInput
-    create: XOR<RouteOrdersCreateWithoutOrderInput, RouteOrdersUncheckedCreateWithoutOrderInput>
+  export type RouteCreateOrConnectWithoutOrderInput = {
+    where: RouteWhereUniqueInput
+    create: XOR<RouteCreateWithoutOrderInput, RouteUncheckedCreateWithoutOrderInput>
   }
 
-  export type RouteOrdersCreateManyOrderInputEnvelope = {
-    data: RouteOrdersCreateManyOrderInput | RouteOrdersCreateManyOrderInput[]
+  export type RouteCreateManyOrderInputEnvelope = {
+    data: RouteCreateManyOrderInput | RouteCreateManyOrderInput[]
     skipDuplicates?: boolean
   }
 
@@ -30235,31 +28804,35 @@ export namespace Prisma {
     data: XOR<HandlingUnitUpdateManyMutationInput, HandlingUnitUncheckedUpdateManyWithoutOrderInput>
   }
 
-  export type RouteOrdersUpsertWithWhereUniqueWithoutOrderInput = {
-    where: RouteOrdersWhereUniqueInput
-    update: XOR<RouteOrdersUpdateWithoutOrderInput, RouteOrdersUncheckedUpdateWithoutOrderInput>
-    create: XOR<RouteOrdersCreateWithoutOrderInput, RouteOrdersUncheckedCreateWithoutOrderInput>
+  export type RouteUpsertWithWhereUniqueWithoutOrderInput = {
+    where: RouteWhereUniqueInput
+    update: XOR<RouteUpdateWithoutOrderInput, RouteUncheckedUpdateWithoutOrderInput>
+    create: XOR<RouteCreateWithoutOrderInput, RouteUncheckedCreateWithoutOrderInput>
   }
 
-  export type RouteOrdersUpdateWithWhereUniqueWithoutOrderInput = {
-    where: RouteOrdersWhereUniqueInput
-    data: XOR<RouteOrdersUpdateWithoutOrderInput, RouteOrdersUncheckedUpdateWithoutOrderInput>
+  export type RouteUpdateWithWhereUniqueWithoutOrderInput = {
+    where: RouteWhereUniqueInput
+    data: XOR<RouteUpdateWithoutOrderInput, RouteUncheckedUpdateWithoutOrderInput>
   }
 
-  export type RouteOrdersUpdateManyWithWhereWithoutOrderInput = {
-    where: RouteOrdersScalarWhereInput
-    data: XOR<RouteOrdersUpdateManyMutationInput, RouteOrdersUncheckedUpdateManyWithoutOrderInput>
+  export type RouteUpdateManyWithWhereWithoutOrderInput = {
+    where: RouteScalarWhereInput
+    data: XOR<RouteUpdateManyMutationInput, RouteUncheckedUpdateManyWithoutOrderInput>
   }
 
-  export type RouteOrdersScalarWhereInput = {
-    AND?: RouteOrdersScalarWhereInput | RouteOrdersScalarWhereInput[]
-    OR?: RouteOrdersScalarWhereInput[]
-    NOT?: RouteOrdersScalarWhereInput | RouteOrdersScalarWhereInput[]
-    id?: UuidFilter<"RouteOrders"> | string
-    route_id?: UuidFilter<"RouteOrders"> | string
-    order_id?: UuidFilter<"RouteOrders"> | string
-    created_at?: DateTimeFilter<"RouteOrders"> | Date | string
-    updated_at?: DateTimeFilter<"RouteOrders"> | Date | string
+  export type RouteScalarWhereInput = {
+    AND?: RouteScalarWhereInput | RouteScalarWhereInput[]
+    OR?: RouteScalarWhereInput[]
+    NOT?: RouteScalarWhereInput | RouteScalarWhereInput[]
+    id?: UuidFilter<"Route"> | string
+    order_id?: UuidNullableFilter<"Route"> | string | null
+    driver_id?: UuidNullableFilter<"Route"> | string | null
+    vehicle_id?: UuidNullableFilter<"Route"> | string | null
+    status?: EnumRouteStatusFilter<"Route"> | $Enums.RouteStatus
+    started_at?: DateTimeNullableFilter<"Route"> | Date | string | null
+    completed_at?: DateTimeNullableFilter<"Route"> | Date | string | null
+    created_at?: DateTimeFilter<"Route"> | Date | string
+    updated_at?: DateTimeFilter<"Route"> | Date | string
   }
 
   export type ClientCreateWithoutCompanyInput = {
@@ -30481,7 +29054,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     shipper?: ClientCreateNestedOneWithoutOrders_as_shipperInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutOrderInput
+    routes?: RouteCreateNestedManyWithoutOrderInput
   }
 
   export type OrderUncheckedCreateWithoutHandling_unitsInput = {
@@ -30492,7 +29065,7 @@ export namespace Prisma {
     status?: $Enums.RouteStatus
     created_at?: Date | string
     updated_at?: Date | string
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutOrderInput
+    routes?: RouteUncheckedCreateNestedManyWithoutOrderInput
   }
 
   export type OrderCreateOrConnectWithoutHandling_unitsInput = {
@@ -30604,7 +29177,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     shipper?: ClientUpdateOneWithoutOrders_as_shipperNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutOrderNestedInput
+    routes?: RouteUpdateManyWithoutOrderNestedInput
   }
 
   export type OrderUncheckedUpdateWithoutHandling_unitsInput = {
@@ -30615,7 +29188,7 @@ export namespace Prisma {
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutOrderNestedInput
+    routes?: RouteUncheckedUpdateManyWithoutOrderNestedInput
   }
 
   export type ClientUpsertWithoutHandling_units_as_consigneeInput = {
@@ -30720,26 +29293,24 @@ export namespace Prisma {
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
+    order?: OrderCreateNestedOneWithoutRoutesInput
     vehicle?: VehicleCreateNestedOneWithoutRoutesInput
     route_handling_units?: RouteHandlingUnitCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutRouteInput
     addresses?: AddressCreateNestedManyWithoutRouteInput
   }
 
   export type RouteUncheckedCreateWithoutDriverInput = {
     id?: string
+    order_id?: string | null
     vehicle_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
     route_handling_units?: RouteHandlingUnitUncheckedCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutRouteInput
     addresses?: AddressUncheckedCreateNestedManyWithoutRouteInput
   }
 
@@ -30825,21 +29396,6 @@ export namespace Prisma {
     data: XOR<RouteUpdateManyMutationInput, RouteUncheckedUpdateManyWithoutDriverInput>
   }
 
-  export type RouteScalarWhereInput = {
-    AND?: RouteScalarWhereInput | RouteScalarWhereInput[]
-    OR?: RouteScalarWhereInput[]
-    NOT?: RouteScalarWhereInput | RouteScalarWhereInput[]
-    id?: UuidFilter<"Route"> | string
-    driver_id?: UuidNullableFilter<"Route"> | string | null
-    vehicle_id?: UuidNullableFilter<"Route"> | string | null
-    status?: EnumRouteStatusFilter<"Route"> | $Enums.RouteStatus
-    started_at?: DateTimeNullableFilter<"Route"> | Date | string | null
-    completed_at?: DateTimeNullableFilter<"Route"> | Date | string | null
-    type_of_route?: EnumTypeOfRoutesNullableFilter<"Route"> | $Enums.TypeOfRoutes | null
-    created_at?: DateTimeFilter<"Route"> | Date | string
-    updated_at?: DateTimeFilter<"Route"> | Date | string
-  }
-
   export type UserCompanyUpsertWithWhereUniqueWithoutUserInput = {
     where: UserCompanyWhereUniqueInput
     update: XOR<UserCompanyUpdateWithoutUserInput, UserCompanyUncheckedUpdateWithoutUserInput>
@@ -31402,26 +29958,24 @@ export namespace Prisma {
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
+    order?: OrderCreateNestedOneWithoutRoutesInput
     driver?: UserCreateNestedOneWithoutRoutesInput
     route_handling_units?: RouteHandlingUnitCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutRouteInput
     addresses?: AddressCreateNestedManyWithoutRouteInput
   }
 
   export type RouteUncheckedCreateWithoutVehicleInput = {
     id?: string
+    order_id?: string | null
     driver_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
     route_handling_units?: RouteHandlingUnitUncheckedCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutRouteInput
     addresses?: AddressUncheckedCreateNestedManyWithoutRouteInput
   }
 
@@ -31548,6 +30102,33 @@ export namespace Prisma {
     data: XOR<RouteUpdateManyMutationInput, RouteUncheckedUpdateManyWithoutVehicleInput>
   }
 
+  export type OrderCreateWithoutRoutesInput = {
+    id?: string
+    reference?: string | null
+    attachments?: NullableJsonNullValueInput | InputJsonValue
+    status?: $Enums.RouteStatus
+    created_at?: Date | string
+    updated_at?: Date | string
+    shipper?: ClientCreateNestedOneWithoutOrders_as_shipperInput
+    handling_units?: HandlingUnitCreateNestedManyWithoutOrderInput
+  }
+
+  export type OrderUncheckedCreateWithoutRoutesInput = {
+    id?: string
+    reference?: string | null
+    shipper_id?: string | null
+    attachments?: NullableJsonNullValueInput | InputJsonValue
+    status?: $Enums.RouteStatus
+    created_at?: Date | string
+    updated_at?: Date | string
+    handling_units?: HandlingUnitUncheckedCreateNestedManyWithoutOrderInput
+  }
+
+  export type OrderCreateOrConnectWithoutRoutesInput = {
+    where: OrderWhereUniqueInput
+    create: XOR<OrderCreateWithoutRoutesInput, OrderUncheckedCreateWithoutRoutesInput>
+  }
+
   export type UserCreateWithoutRoutesInput = {
     id?: string
     email: string
@@ -31642,30 +30223,6 @@ export namespace Prisma {
     skipDuplicates?: boolean
   }
 
-  export type RouteOrdersCreateWithoutRouteInput = {
-    id?: string
-    created_at?: Date | string
-    updated_at?: Date | string
-    order: OrderCreateNestedOneWithoutRoute_ordersInput
-  }
-
-  export type RouteOrdersUncheckedCreateWithoutRouteInput = {
-    id?: string
-    order_id: string
-    created_at?: Date | string
-    updated_at?: Date | string
-  }
-
-  export type RouteOrdersCreateOrConnectWithoutRouteInput = {
-    where: RouteOrdersWhereUniqueInput
-    create: XOR<RouteOrdersCreateWithoutRouteInput, RouteOrdersUncheckedCreateWithoutRouteInput>
-  }
-
-  export type RouteOrdersCreateManyRouteInputEnvelope = {
-    data: RouteOrdersCreateManyRouteInput | RouteOrdersCreateManyRouteInput[]
-    skipDuplicates?: boolean
-  }
-
   export type AddressCreateWithoutRouteInput = {
     id?: string
     address_type?: $Enums.AddressType
@@ -31716,6 +30273,39 @@ export namespace Prisma {
     skipDuplicates?: boolean
   }
 
+  export type OrderUpsertWithoutRoutesInput = {
+    update: XOR<OrderUpdateWithoutRoutesInput, OrderUncheckedUpdateWithoutRoutesInput>
+    create: XOR<OrderCreateWithoutRoutesInput, OrderUncheckedCreateWithoutRoutesInput>
+    where?: OrderWhereInput
+  }
+
+  export type OrderUpdateToOneWithWhereWithoutRoutesInput = {
+    where?: OrderWhereInput
+    data: XOR<OrderUpdateWithoutRoutesInput, OrderUncheckedUpdateWithoutRoutesInput>
+  }
+
+  export type OrderUpdateWithoutRoutesInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    reference?: NullableStringFieldUpdateOperationsInput | string | null
+    attachments?: NullableJsonNullValueInput | InputJsonValue
+    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    shipper?: ClientUpdateOneWithoutOrders_as_shipperNestedInput
+    handling_units?: HandlingUnitUpdateManyWithoutOrderNestedInput
+  }
+
+  export type OrderUncheckedUpdateWithoutRoutesInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    reference?: NullableStringFieldUpdateOperationsInput | string | null
+    shipper_id?: NullableStringFieldUpdateOperationsInput | string | null
+    attachments?: NullableJsonNullValueInput | InputJsonValue
+    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    handling_units?: HandlingUnitUncheckedUpdateManyWithoutOrderNestedInput
+  }
+
   export type UserUpsertWithoutRoutesInput = {
     update: XOR<UserUpdateWithoutRoutesInput, UserUncheckedUpdateWithoutRoutesInput>
     create: XOR<UserCreateWithoutRoutesInput, UserUncheckedCreateWithoutRoutesInput>
@@ -31814,22 +30404,6 @@ export namespace Prisma {
     data: XOR<RouteHandlingUnitUpdateManyMutationInput, RouteHandlingUnitUncheckedUpdateManyWithoutRouteInput>
   }
 
-  export type RouteOrdersUpsertWithWhereUniqueWithoutRouteInput = {
-    where: RouteOrdersWhereUniqueInput
-    update: XOR<RouteOrdersUpdateWithoutRouteInput, RouteOrdersUncheckedUpdateWithoutRouteInput>
-    create: XOR<RouteOrdersCreateWithoutRouteInput, RouteOrdersUncheckedCreateWithoutRouteInput>
-  }
-
-  export type RouteOrdersUpdateWithWhereUniqueWithoutRouteInput = {
-    where: RouteOrdersWhereUniqueInput
-    data: XOR<RouteOrdersUpdateWithoutRouteInput, RouteOrdersUncheckedUpdateWithoutRouteInput>
-  }
-
-  export type RouteOrdersUpdateManyWithWhereWithoutRouteInput = {
-    where: RouteOrdersScalarWhereInput
-    data: XOR<RouteOrdersUpdateManyMutationInput, RouteOrdersUncheckedUpdateManyWithoutRouteInput>
-  }
-
   export type AddressUpsertWithWhereUniqueWithoutRouteInput = {
     where: AddressWhereUniqueInput
     update: XOR<AddressUpdateWithoutRouteInput, AddressUncheckedUpdateWithoutRouteInput>
@@ -31874,26 +30448,24 @@ export namespace Prisma {
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
+    order?: OrderCreateNestedOneWithoutRoutesInput
     driver?: UserCreateNestedOneWithoutRoutesInput
     vehicle?: VehicleCreateNestedOneWithoutRoutesInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutRouteInput
     addresses?: AddressCreateNestedManyWithoutRouteInput
   }
 
   export type RouteUncheckedCreateWithoutRoute_handling_unitsInput = {
     id?: string
+    order_id?: string | null
     driver_id?: string | null
     vehicle_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutRouteInput
     addresses?: AddressUncheckedCreateNestedManyWithoutRouteInput
   }
 
@@ -31981,26 +30553,24 @@ export namespace Prisma {
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    order?: OrderUpdateOneWithoutRoutesNestedInput
     driver?: UserUpdateOneWithoutRoutesNestedInput
     vehicle?: VehicleUpdateOneWithoutRoutesNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutRouteNestedInput
     addresses?: AddressUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteUncheckedUpdateWithoutRoute_handling_unitsInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     driver_id?: NullableStringFieldUpdateOperationsInput | string | null
     vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutRouteNestedInput
     addresses?: AddressUncheckedUpdateManyWithoutRouteNestedInput
   }
 
@@ -32073,164 +30643,30 @@ export namespace Prisma {
     address_handling_units?: AddressHandlingUnitUncheckedUpdateManyWithoutHandling_unitNestedInput
   }
 
-  export type RouteCreateWithoutRoute_ordersInput = {
-    id?: string
-    status?: $Enums.RouteStatus
-    started_at?: Date | string | null
-    completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
-    created_at?: Date | string
-    updated_at?: Date | string
-    driver?: UserCreateNestedOneWithoutRoutesInput
-    vehicle?: VehicleCreateNestedOneWithoutRoutesInput
-    route_handling_units?: RouteHandlingUnitCreateNestedManyWithoutRouteInput
-    addresses?: AddressCreateNestedManyWithoutRouteInput
-  }
-
-  export type RouteUncheckedCreateWithoutRoute_ordersInput = {
-    id?: string
-    driver_id?: string | null
-    vehicle_id?: string | null
-    status?: $Enums.RouteStatus
-    started_at?: Date | string | null
-    completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
-    created_at?: Date | string
-    updated_at?: Date | string
-    route_handling_units?: RouteHandlingUnitUncheckedCreateNestedManyWithoutRouteInput
-    addresses?: AddressUncheckedCreateNestedManyWithoutRouteInput
-  }
-
-  export type RouteCreateOrConnectWithoutRoute_ordersInput = {
-    where: RouteWhereUniqueInput
-    create: XOR<RouteCreateWithoutRoute_ordersInput, RouteUncheckedCreateWithoutRoute_ordersInput>
-  }
-
-  export type OrderCreateWithoutRoute_ordersInput = {
-    id?: string
-    reference?: string | null
-    attachments?: NullableJsonNullValueInput | InputJsonValue
-    status?: $Enums.RouteStatus
-    created_at?: Date | string
-    updated_at?: Date | string
-    shipper?: ClientCreateNestedOneWithoutOrders_as_shipperInput
-    handling_units?: HandlingUnitCreateNestedManyWithoutOrderInput
-  }
-
-  export type OrderUncheckedCreateWithoutRoute_ordersInput = {
-    id?: string
-    reference?: string | null
-    shipper_id?: string | null
-    attachments?: NullableJsonNullValueInput | InputJsonValue
-    status?: $Enums.RouteStatus
-    created_at?: Date | string
-    updated_at?: Date | string
-    handling_units?: HandlingUnitUncheckedCreateNestedManyWithoutOrderInput
-  }
-
-  export type OrderCreateOrConnectWithoutRoute_ordersInput = {
-    where: OrderWhereUniqueInput
-    create: XOR<OrderCreateWithoutRoute_ordersInput, OrderUncheckedCreateWithoutRoute_ordersInput>
-  }
-
-  export type RouteUpsertWithoutRoute_ordersInput = {
-    update: XOR<RouteUpdateWithoutRoute_ordersInput, RouteUncheckedUpdateWithoutRoute_ordersInput>
-    create: XOR<RouteCreateWithoutRoute_ordersInput, RouteUncheckedCreateWithoutRoute_ordersInput>
-    where?: RouteWhereInput
-  }
-
-  export type RouteUpdateToOneWithWhereWithoutRoute_ordersInput = {
-    where?: RouteWhereInput
-    data: XOR<RouteUpdateWithoutRoute_ordersInput, RouteUncheckedUpdateWithoutRoute_ordersInput>
-  }
-
-  export type RouteUpdateWithoutRoute_ordersInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
-    started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    driver?: UserUpdateOneWithoutRoutesNestedInput
-    vehicle?: VehicleUpdateOneWithoutRoutesNestedInput
-    route_handling_units?: RouteHandlingUnitUpdateManyWithoutRouteNestedInput
-    addresses?: AddressUpdateManyWithoutRouteNestedInput
-  }
-
-  export type RouteUncheckedUpdateWithoutRoute_ordersInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    driver_id?: NullableStringFieldUpdateOperationsInput | string | null
-    vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
-    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
-    started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    route_handling_units?: RouteHandlingUnitUncheckedUpdateManyWithoutRouteNestedInput
-    addresses?: AddressUncheckedUpdateManyWithoutRouteNestedInput
-  }
-
-  export type OrderUpsertWithoutRoute_ordersInput = {
-    update: XOR<OrderUpdateWithoutRoute_ordersInput, OrderUncheckedUpdateWithoutRoute_ordersInput>
-    create: XOR<OrderCreateWithoutRoute_ordersInput, OrderUncheckedCreateWithoutRoute_ordersInput>
-    where?: OrderWhereInput
-  }
-
-  export type OrderUpdateToOneWithWhereWithoutRoute_ordersInput = {
-    where?: OrderWhereInput
-    data: XOR<OrderUpdateWithoutRoute_ordersInput, OrderUncheckedUpdateWithoutRoute_ordersInput>
-  }
-
-  export type OrderUpdateWithoutRoute_ordersInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    reference?: NullableStringFieldUpdateOperationsInput | string | null
-    attachments?: NullableJsonNullValueInput | InputJsonValue
-    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    shipper?: ClientUpdateOneWithoutOrders_as_shipperNestedInput
-    handling_units?: HandlingUnitUpdateManyWithoutOrderNestedInput
-  }
-
-  export type OrderUncheckedUpdateWithoutRoute_ordersInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    reference?: NullableStringFieldUpdateOperationsInput | string | null
-    shipper_id?: NullableStringFieldUpdateOperationsInput | string | null
-    attachments?: NullableJsonNullValueInput | InputJsonValue
-    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    handling_units?: HandlingUnitUncheckedUpdateManyWithoutOrderNestedInput
-  }
-
   export type RouteCreateWithoutAddressesInput = {
     id?: string
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
+    order?: OrderCreateNestedOneWithoutRoutesInput
     driver?: UserCreateNestedOneWithoutRoutesInput
     vehicle?: VehicleCreateNestedOneWithoutRoutesInput
     route_handling_units?: RouteHandlingUnitCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersCreateNestedManyWithoutRouteInput
   }
 
   export type RouteUncheckedCreateWithoutAddressesInput = {
     id?: string
+    order_id?: string | null
     driver_id?: string | null
     vehicle_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
     route_handling_units?: RouteHandlingUnitUncheckedCreateNestedManyWithoutRouteInput
-    route_orders?: RouteOrdersUncheckedCreateNestedManyWithoutRouteInput
   }
 
   export type RouteCreateOrConnectWithoutAddressesInput = {
@@ -32278,27 +30714,25 @@ export namespace Prisma {
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    order?: OrderUpdateOneWithoutRoutesNestedInput
     driver?: UserUpdateOneWithoutRoutesNestedInput
     vehicle?: VehicleUpdateOneWithoutRoutesNestedInput
     route_handling_units?: RouteHandlingUnitUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteUncheckedUpdateWithoutAddressesInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     driver_id?: NullableStringFieldUpdateOperationsInput | string | null
     vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     route_handling_units?: RouteHandlingUnitUncheckedUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutRouteNestedInput
   }
 
   export type AddressHandlingUnitUpsertWithWhereUniqueWithoutAddressInput = {
@@ -32701,7 +31135,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     handling_units?: HandlingUnitUpdateManyWithoutOrderNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutOrderNestedInput
+    routes?: RouteUpdateManyWithoutOrderNestedInput
   }
 
   export type OrderUncheckedUpdateWithoutShipperInput = {
@@ -32712,7 +31146,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     handling_units?: HandlingUnitUncheckedUpdateManyWithoutOrderNestedInput
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutOrderNestedInput
+    routes?: RouteUncheckedUpdateManyWithoutOrderNestedInput
   }
 
   export type OrderUncheckedUpdateManyWithoutShipperInput = {
@@ -32836,9 +31270,13 @@ export namespace Prisma {
     updated_at?: Date | string
   }
 
-  export type RouteOrdersCreateManyOrderInput = {
+  export type RouteCreateManyOrderInput = {
     id?: string
-    route_id: string
+    driver_id?: string | null
+    vehicle_id?: string | null
+    status?: $Enums.RouteStatus
+    started_at?: Date | string | null
+    completed_at?: Date | string | null
     created_at?: Date | string
     updated_at?: Date | string
   }
@@ -32928,23 +31366,39 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
-  export type RouteOrdersUpdateWithoutOrderInput = {
+  export type RouteUpdateWithoutOrderInput = {
     id?: StringFieldUpdateOperationsInput | string
+    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
+    started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+    completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    route?: RouteUpdateOneRequiredWithoutRoute_ordersNestedInput
+    driver?: UserUpdateOneWithoutRoutesNestedInput
+    vehicle?: VehicleUpdateOneWithoutRoutesNestedInput
+    route_handling_units?: RouteHandlingUnitUpdateManyWithoutRouteNestedInput
+    addresses?: AddressUpdateManyWithoutRouteNestedInput
   }
 
-  export type RouteOrdersUncheckedUpdateWithoutOrderInput = {
+  export type RouteUncheckedUpdateWithoutOrderInput = {
     id?: StringFieldUpdateOperationsInput | string
-    route_id?: StringFieldUpdateOperationsInput | string
+    driver_id?: NullableStringFieldUpdateOperationsInput | string | null
+    vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
+    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
+    started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+    completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    route_handling_units?: RouteHandlingUnitUncheckedUpdateManyWithoutRouteNestedInput
+    addresses?: AddressUncheckedUpdateManyWithoutRouteNestedInput
   }
 
-  export type RouteOrdersUncheckedUpdateManyWithoutOrderInput = {
+  export type RouteUncheckedUpdateManyWithoutOrderInput = {
     id?: StringFieldUpdateOperationsInput | string
-    route_id?: StringFieldUpdateOperationsInput | string
+    driver_id?: NullableStringFieldUpdateOperationsInput | string | null
+    vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
+    status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
+    started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+    completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -33165,11 +31619,11 @@ export namespace Prisma {
 
   export type RouteCreateManyDriverInput = {
     id?: string
+    order_id?: string | null
     vehicle_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
   }
@@ -33197,36 +31651,34 @@ export namespace Prisma {
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    order?: OrderUpdateOneWithoutRoutesNestedInput
     vehicle?: VehicleUpdateOneWithoutRoutesNestedInput
     route_handling_units?: RouteHandlingUnitUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutRouteNestedInput
     addresses?: AddressUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteUncheckedUpdateWithoutDriverInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     route_handling_units?: RouteHandlingUnitUncheckedUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutRouteNestedInput
     addresses?: AddressUncheckedUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteUncheckedUpdateManyWithoutDriverInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     vehicle_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -33461,11 +31913,11 @@ export namespace Prisma {
 
   export type RouteCreateManyVehicleInput = {
     id?: string
+    order_id?: string | null
     driver_id?: string | null
     status?: $Enums.RouteStatus
     started_at?: Date | string | null
     completed_at?: Date | string | null
-    type_of_route?: $Enums.TypeOfRoutes | null
     created_at?: Date | string
     updated_at?: Date | string
   }
@@ -33475,36 +31927,34 @@ export namespace Prisma {
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    order?: OrderUpdateOneWithoutRoutesNestedInput
     driver?: UserUpdateOneWithoutRoutesNestedInput
     route_handling_units?: RouteHandlingUnitUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUpdateManyWithoutRouteNestedInput
     addresses?: AddressUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteUncheckedUpdateWithoutVehicleInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     driver_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     route_handling_units?: RouteHandlingUnitUncheckedUpdateManyWithoutRouteNestedInput
-    route_orders?: RouteOrdersUncheckedUpdateManyWithoutRouteNestedInput
     addresses?: AddressUncheckedUpdateManyWithoutRouteNestedInput
   }
 
   export type RouteUncheckedUpdateManyWithoutVehicleInput = {
     id?: StringFieldUpdateOperationsInput | string
+    order_id?: NullableStringFieldUpdateOperationsInput | string | null
     driver_id?: NullableStringFieldUpdateOperationsInput | string | null
     status?: EnumRouteStatusFieldUpdateOperationsInput | $Enums.RouteStatus
     started_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     completed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
-    type_of_route?: NullableEnumTypeOfRoutesFieldUpdateOperationsInput | $Enums.TypeOfRoutes | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -33516,13 +31966,6 @@ export namespace Prisma {
     updated_at?: Date | string
   }
 
-  export type RouteOrdersCreateManyRouteInput = {
-    id?: string
-    order_id: string
-    created_at?: Date | string
-    updated_at?: Date | string
-  }
-
   export type AddressCreateManyRouteInput = {
     id?: string
     address_type?: $Enums.AddressType
@@ -33563,27 +32006,6 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
-  export type RouteOrdersUpdateWithoutRouteInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    order?: OrderUpdateOneRequiredWithoutRoute_ordersNestedInput
-  }
-
-  export type RouteOrdersUncheckedUpdateWithoutRouteInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    order_id?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-  }
-
-  export type RouteOrdersUncheckedUpdateManyWithoutRouteInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    order_id?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-  }
-
   export type AddressUpdateWithoutRouteInput = {
     id?: StringFieldUpdateOperationsInput | string
     address_type?: EnumAddressTypeFieldUpdateOperationsInput | $Enums.AddressType