@chargetrip/types 1.58.0 → 1.60.0

package/dist/ts/graphql.d.ts

@@ -146,10 +146,7 @@ export declare enum Amenities {
 }
 /** Amenity data. */
 export declare type Amenity = {
-    /**
-     * Unique amenity ID.
-     * @deprecated Will be removed.
-     */
+    /** Unique amenity ID. */
     id?: Maybe<Scalars["ID"]>;
     /**
      * ID provided by an amenity data source as the row ID.
@@ -1251,6 +1248,50 @@ export declare type CreateRouteInput = {
     /** [BETA] Route should consider current traffic conditions. This feature is disabled by default and requires explicit enablement for your project. Please contact Chargetrip support for more information. */
     traffic_aware?: Maybe<Scalars["Boolean"]>;
 };
+export declare type CreateTruckRoute = {
+    /** Vehicle specific input. */
+    vehicle: RouteTruckVehicle;
+    /** Origin of a route. */
+    origin: RouteTruckOriginFeaturePoint;
+    /** Destination of a route. */
+    destination: RouteDestinationFeaturePoint;
+    /** Optional via points of a route. */
+    via?: Maybe<Array<RouteTruckViaFeaturePoint>>;
+    /** Prioritized operators for a route calculation. */
+    operators?: Maybe<RouteOperatorPreferences>;
+    /** Weather configuration for the route. Defined by a preset or custom weather conditions. */
+    weather?: Maybe<RouteWeather>;
+    /** Alternative stations along a route within a specified radius of 500 to 5000 meters, or the equivalent in another unit. If not specified, no alternative stations will be discovered. */
+    alternative_station_radius?: Maybe<AlternativeStationRadius>;
+    /** Route departure time. Used to calculate the expected arrival time and, if set in the past, to apply historical weather data. If not specified, defaults to the current request time. */
+    departure_time?: Maybe<Scalars["DateTime"]>;
+    /** Optional list of route features to avoid in a route. This is a best-effort preference; depending on the available routes, some features may not be fully avoidable. */
+    avoid?: Maybe<Array<RouteTruckAvoid>>;
+    /** Maximum speed to consider when generating the route. In the segments where legal speed is lower than this value, the legal speed will be used instead. */
+    maximum_speed?: Maybe<MaximumSpeed>;
+};
+export declare type CreateTruckRouteInput = {
+    /** Vehicle specific input. */
+    vehicle: RouteTruckVehicleInput;
+    /** Origin of a route. */
+    origin: RouteTruckOriginFeaturePointInput;
+    /** Destination of a route. */
+    destination: RouteDestinationFeaturePointInput;
+    /** Optional via points of a route. */
+    via?: Maybe<Array<RouteTruckViaFeaturePointInput>>;
+    /** Prioritized operators for a route calculation. */
+    operators?: Maybe<RouteOperatorPreferencesInput>;
+    /** Weather configuration for the route. Defined by a preset or custom weather conditions. */
+    weather?: Maybe<RouteWeatherInput>;
+    /** Alternative stations along a route within a specified radius of 500 to 5000 meters, or the equivalent in another unit. If not specified, no alternative stations will be discovered. */
+    alternative_station_radius?: Maybe<AlternativeStationRadiusInput>;
+    /** Route departure time. Used to calculate the expected arrival time and, if set in the past, to apply historical weather data. If not specified, defaults to the current request time. */
+    departure_time?: Maybe<Scalars["DateTime"]>;
+    /** Optional list of route features to avoid in a route. This is a best-effort preference; depending on the available routes, some features may not be fully avoidable. */
+    avoid?: Maybe<Array<RouteTruckAvoid>>;
+    /** Maximum speed to consider when generating the route. In the segments where legal speed is lower than this value, the legal speed will be used instead. */
+    maximum_speed?: Maybe<MaximumSpeedInput>;
+};
 /** Currency in the ISO 4217 format. */
 export declare enum Currency {
     AED = "AED",
@@ -1593,6 +1634,12 @@ export declare enum DimensionUnit {
     /** Return the dimension in miles. */
     MILE = "mile"
 }
+export declare type DimensionsInput = {
+    /** Value of the dimension */
+    value: Scalars["Float"];
+    /** Dimension unit */
+    type: MeasurementUnit;
+};
 export declare type DistanceInput = {
     /** Value of the distance. */
     value: Scalars["Float"];
@@ -2134,6 +2181,8 @@ export declare type Mutation = {
     newRoute?: Maybe<Scalars["ID"]>;
     /** Create a new route from the route input. */
     createRoute: Scalars["ID"];
+    /** [ALPHA] Create a new truck route from the route input and its ID. */
+    createTruckRoute: Scalars["ID"];
 };
 export declare type MutationcreateConnectedVehicleArgs = {
     input?: Maybe<CreateConnectedVehicleInput>;
@@ -2174,6 +2223,9 @@ export declare type MutationnewRouteArgs = {
 export declare type MutationcreateRouteArgs = {
     input: CreateRouteInput;
 };
+export declare type MutationcreateTruckRouteArgs = {
+    input: CreateTruckRouteInput;
+};
 /** Navigation session data. */
 export declare type Navigation = {
     /** ID of the navigation session. */
@@ -3416,6 +3468,8 @@ export declare type Query = {
     getRoute: RouteResponse;
     /** [BETA] Search for stations with amenities within a specific time window and distance of a previously calculated route. */
     getRouteStationsWithAmenities: RouteStationsWithAmenitiesConnection;
+    /** [ALPHA] Get a e-truck route by ID. */
+    getTruckRoute: TruckRouteResponse;
     /** Get information about a station by its ID. */
     station?: Maybe<Station>;
     /** Get a full list of stations. */
@@ -3507,6 +3561,9 @@ export declare type QuerygetRouteStationsWithAmenitiesArgs = {
     first?: Maybe<Scalars["Int"]>;
     after?: Maybe<Scalars["String"]>;
 };
+export declare type QuerygetTruckRouteArgs = {
+    id: Scalars["ID"];
+};
 export declare type QuerystationArgs = {
     id?: Maybe<Scalars["ID"]>;
     evse_id?: Maybe<Scalars["String"]>;
@@ -3823,9 +3880,9 @@ export declare type Review = {
     /** Boolean tags for a station review. */
     tags?: Maybe<ReviewTags>;
     /** Date and time when a review was created. */
-    createdAt?: Maybe<Scalars["String"]>;
+    createdAt?: Maybe<Scalars["DateTime"]>;
     /** Date and time when a review was updated. */
-    updatedAt?: Maybe<Scalars["String"]>;
+    updatedAt?: Maybe<Scalars["DateTime"]>;
 };
 /** Form input to add a new review. */
 export declare type ReviewAdd = {
@@ -5597,6 +5654,170 @@ export declare type RouteTimeWindow = {
     /** Duration in seconds to extend the search on either side of the 'center'. Maximum allowed value is 2700 (45 minutes). If not specified, defaults to 900 seconds (15 minutes). */
     margin?: Maybe<Scalars["Int"]>;
 };
+/** Types of route features that can be avoided in truck routing. */
+export declare enum RouteTruckAvoid {
+    TOLL_ROAD = "toll_road",
+    FERRY = "ferry"
+}
+export declare type RouteTruckOriginFeaturePoint = {
+    /** ID of the feature. */
+    id?: Maybe<Scalars["ID"]>;
+    /** Feature type. */
+    type: FeatureType;
+    /** Geometry of the feature. */
+    geometry: Point;
+    /** Additional location and vehicle properties can be specified. */
+    properties?: Maybe<RouteTruckOriginProperties>;
+};
+export declare type RouteTruckOriginFeaturePointInput = {
+    /** ID of the feature. */
+    id?: Maybe<Scalars["ID"]>;
+    /** Feature type. */
+    type: FeatureType;
+    /** Geometry of the feature. */
+    geometry: PointInput;
+    /** Additional location and vehicle properties can be specified. */
+    properties?: Maybe<RouteTruckOriginPropertiesInput>;
+};
+export declare type RouteTruckOriginProperties = {
+    /** Data about the origin location. */
+    location?: Maybe<RouteTruckPropertiesLocation>;
+    /** Vehicle configuration at this point. Properties defined here are persistent and will be applied to all subsequent via points in the route unless explicitly overridden at a specific point. If not specified, assumes one occupant, with 80kg of mass and no trailers added */
+    vehicle?: Maybe<RouteTruckPropertiesVehicle>;
+};
+export declare type RouteTruckOriginPropertiesInput = {
+    /** Data about the origin location. */
+    location?: Maybe<RouteTruckPropertiesLocationInput>;
+    /** Vehicle configuration at this point. Properties defined here are persistent and will be applied to all subsequent via points in the route unless explicitly overridden at a specific point. If not specified, assumes one occupant, with 80kg of mass and no trailers added */
+    vehicle?: Maybe<RouteTruckPropertiesVehicleInput>;
+};
+export declare type RouteTruckPropertiesLocation = {
+    /** Name override for the choosen location. */
+    name?: Maybe<Scalars["String"]>;
+};
+export declare type RouteTruckPropertiesLocationInput = {
+    /** Name override for the choosen location. */
+    name?: Maybe<Scalars["String"]>;
+};
+export declare type RouteTruckPropertiesVehicle = {
+    /** Number of occupants in the vehicle. */
+    occupants: Scalars["Int"];
+    /** Combined weight of the all occupants. Defaults to 80kg if not specified. */
+    total_occupant_weight?: Maybe<TotalOccupantWeight>;
+    /** Total weight of all cargo in the vehicle, including the cargo in any attached trailers. */
+    total_cargo_weight?: Maybe<TotalCargoWeight>;
+    /** The number of axles of the main vehicle (e.g., rigid truck or tractor unit) in contact with the road. Excludes semi-trailer axles, those should be provided in trailer object. If not specified, it assumes  main vehicle's all axles (liftable and rigid) are in use. */
+    axles_in_use?: Maybe<Scalars["Int"]>;
+    /** Configuration and dimensions for attached trailers. Required when the choosen vehicle is tractor unit. If not specified, no trailer configuration is set . */
+    trailer?: Maybe<RouteTruckVehicleTrailer>;
+};
+export declare type RouteTruckPropertiesVehicleInput = {
+    /** Number of occupants in the vehicle. Defaults to 1 if not specified. */
+    occupants?: Maybe<Scalars["Int"]>;
+    /** Combined weight of the all occupants. Defaults to 80kg if not specified. */
+    total_occupant_weight?: Maybe<TotalOccupantWeightInput>;
+    /** Total weight of all cargo in the vehicle, including the cargo in any attached trailers. */
+    total_cargo_weight?: Maybe<TotalCargoWeightInput>;
+    /** The number of axles of the main vehicle (e.g., rigid truck or tractor unit) in contact with the road. Excludes semi-trailer axles, those should be provided in trailer object. If not specified, it assumes  main vehicle's all axles (liftable and rigid) are in use. */
+    axles_in_use?: Maybe<Scalars["Int"]>;
+    /** Configuration and dimensions for attached trailers. Required when the choosen vehicle is tractor unit. If not specified, no trailer configuration is set . */
+    trailer?: Maybe<RouteTruckVehicleTrailerInput>;
+};
+export declare type RouteTruckVehicle = {
+    /** ID of the vehicle. */
+    id: Scalars["ID"];
+    /** EV battery specific configuration. */
+    battery: RouteVehicleBattery;
+    /** Charging configuration. */
+    charging: RouteVehicleCharging;
+    /** Value of the auxiliary power consumption of the vehicle. */
+    auxiliary_consumption: AuxiliaryConsumption;
+    /** Flag indicating if climate control is on. */
+    climate: Scalars["Boolean"];
+    /** Vehicle Heat Pump configuration. */
+    heat_pump: HeatPumpMode;
+    /** Vehicle cabin configuration used for the route calculation. Applied only if vehicle.climate is set to true. */
+    cabin: RouteVehicleCabin;
+    /** Tire pressures of all wheels, ordered from front right to front left, then rear left to rear right. */
+    tire_pressure: TirePressure;
+};
+export declare type RouteTruckVehicleInput = {
+    /** ID of the vehicle. */
+    id: Scalars["ID"];
+    /** EV battery specific configuration. */
+    battery?: Maybe<RouteVehicleBatteryInput>;
+    /** Charging configuration. */
+    charging?: Maybe<RouteVehicleChargingInput>;
+    /** Value of the auxiliary power consumption of the vehicle. */
+    auxiliary_consumption?: Maybe<AuxiliaryConsumptionInput>;
+    /** Flag indicating if climate control is on. */
+    climate?: Maybe<Scalars["Boolean"]>;
+    /** Vehicle Heat Pump configuration. */
+    heat_pump?: Maybe<HeatPumpMode>;
+    /** Vehicle cabin configuration used for the route calculation. Applied only if vehicle.climate is set to true. */
+    cabin?: Maybe<RouteVehicleCabinInput>;
+    /** Tire pressures of all wheels, ordered from front right to front left, then rear left to rear right. */
+    tire_pressure?: Maybe<TirePressureInput>;
+};
+export declare type RouteTruckVehicleTrailer = {
+    /** Number of trailers. */
+    count: Scalars["Int"];
+    /** Number of axles of all attached trailers in contact with the road. This value does not include the main vehicle/tractor unit axles. Will be combined with the main vehicle's known number of axles. */
+    axles_in_use: Scalars["Int"];
+    /** Total unladen (empty) weight of all attached trailers. Will be combined with the main vehicle's known unladen weight. */
+    unladen_weight: Scalars["Float"];
+    /** Total physical dimensions of the vehicle combination of the main vehicle and trailers. */
+    combined_vehicle_dimensions: TruckTrailerCombinedDimensions;
+};
+export declare type RouteTruckVehicleTrailerunladen_weightArgs = {
+    unit?: Maybe<WeightUnit>;
+};
+export declare type RouteTruckVehicleTrailerInput = {
+    /** Number of trailers. */
+    count: Scalars["Int"];
+    /** Number of axles of all attached trailers in contact with the road. This value does not include the main vehicle/tractor unit axles. Will be combined with the main vehicle's known number of axles. */
+    axles_in_use: Scalars["Int"];
+    /** Total unladen (empty) weight of all attached trailers. Will be combined with the main vehicle's known unladen weight. */
+    unladen_weight: WeightInput;
+    /** Total physical dimensions of the vehicle combination of the main vehicle and trailers. */
+    combined_vehicle_dimensions: TruckTrailerCombinedDimensionsInput;
+};
+export declare type RouteTruckViaFeaturePoint = {
+    /** ID of the feature. */
+    id?: Maybe<Scalars["ID"]>;
+    /** Feature type. */
+    type: FeatureType;
+    /** Geometry of the feature. */
+    geometry?: Maybe<Point>;
+    /** Optional object where additional properties can be specified. */
+    properties?: Maybe<RouteTruckViaProperties>;
+};
+export declare type RouteTruckViaFeaturePointInput = {
+    /** ID of the feature. */
+    id?: Maybe<Scalars["ID"]>;
+    /** Feature type. */
+    type: FeatureType;
+    /** Geometry of the feature. */
+    geometry?: Maybe<PointInput>;
+    /** Optional object where additional properties can be specified. */
+    properties?: Maybe<RouteTruckViaPropertiesInput>;
+};
+export declare type RouteTruckViaProperties = {
+    /** Location data of the via point. */
+    location?: Maybe<RoutePropertiesViaLocation>;
+    /** Vehicle configuration at this point. Properties defined here override previous settings and persist for all subsequent segments of the route until changed again. If not specified, the vehicle state from the previous point remains in effect. */
+    vehicle?: Maybe<RouteTruckPropertiesVehicle>;
+    /** Station data of the via point. */
+    station?: Maybe<RoutePropertiesStation>;
+};
+export declare type RouteTruckViaPropertiesInput = {
+    /** Location data of the via point. */
+    location?: Maybe<RoutePropertiesViaLocationInput>;
+    /** Vehicle configuration at this point. Properties defined here override previous settings and persist for all subsequent segments of the route until changed again. If not specified, the vehicle state from the previous point remains in effect. */
+    vehicle?: Maybe<RouteTruckPropertiesVehicleInput>;
+    /** Station data of the via point. */
+    station?: Maybe<RoutePropertiesStationInput>;
+};
 export declare type RouteVehicle = {
     /** ID of the vehicle. */
     id: Scalars["ID"];
@@ -6314,6 +6535,8 @@ export declare type Subscription = {
     routeUpdatedById?: Maybe<Route>;
     /** Subscribe to a specific route to receive system event updates. */
     route: RouteResponse;
+    /** [ALPHA] Subscribe to e-truck route to receive system event updates. */
+    truckRoute: TruckRouteResponse;
     /** [BETA] Subscribe to navigation session system event updates. We strongly recommend using this at all times to not miss any updates. */
     navigation?: Maybe<NavigationSubscription>;
     /** [BETA] Subscribe to a connected vehicle. */
@@ -6327,6 +6550,9 @@ export declare type SubscriptionrouteUpdatedByIdArgs = {
 export declare type SubscriptionrouteArgs = {
     id: Scalars["ID"];
 };
+export declare type SubscriptiontruckRouteArgs = {
+    id: Scalars["ID"];
+};
 export declare type SubscriptionnavigationArgs = {
     id: Scalars["ID"];
 };
@@ -6551,6 +6777,234 @@ export declare type TrafficCongestionInterval = {
     /** Congestion level for this specific interval. */
     level: CongestionLevel;
 };
+export declare type TruckRouteDetails = {
+    /** ID of a route computation. */
+    id: Scalars["ID"];
+    /** Total distance of a route. */
+    distance: Scalars["Float"];
+    /** Aggregation of all durations of a route. */
+    durations: RouteDetailsDurations;
+    /** Total energy used for a route in kilowatt hours. For HEVs and PHEVs this field will return null. */
+    consumption?: Maybe<Scalars["Float"]>;
+    /** Range available at the start of a trip. The ranges in kilometers and miles are estimates, calculated based on the Chargetrip range, current route conditions, weather scenario (current or seasonal), and the route input at the time of planning. For HEVs and PHEVs this field will return null. */
+    range_at_origin?: Maybe<Scalars["Float"]>;
+    /** Range available at the end of a trip. Note: The ranges in kilometers and miles are estimates, calculated based on the Chargetrip range, current route conditions, weather scenario (current or seasonal), and the route input at the time of planning. For HEVs and PHEVs this field will return null. */
+    range_at_destination?: Maybe<Scalars["Float"]>;
+    /** Polyline containing encoded coordinates. */
+    polyline: Scalars["String"];
+    /** Path elevation, distance, duration, consumption and speed values, grouped into 100 segments. */
+    path_plot: Array<RouteDetailsPathSegment>;
+    /** Details about elevation on a route. */
+    elevation: RouteDetailsElevation;
+    /** Money saving information. */
+    savings?: Maybe<RouteDetailsSavings>;
+    /** Legs of a route. */
+    legs: Array<TruckRouteDetailsLeg>;
+    /** Alternative stations along a route within a specified radius. Will only return stations if alternative_station_radius was specified in the createRoute mutation. */
+    alternative_stations: Array<RouteDetailsAlternativeStation>;
+    /** Aggregation of tags over the current RouteDetails. Tags are available on legs and further subdivided over individual sections and maneuvers. */
+    tags: Array<RouteDetailsTag>;
+    /** Number of charging stops required for this route. */
+    charges: Scalars["Int"];
+};
+export declare type TruckRouteDetailsdistanceArgs = {
+    unit?: Maybe<DistanceUnit>;
+};
+export declare type TruckRouteDetailsrange_at_originArgs = {
+    unit?: Maybe<StateOfChargeUnit>;
+};
+export declare type TruckRouteDetailsrange_at_destinationArgs = {
+    unit?: Maybe<StateOfChargeUnit>;
+};
+export declare type TruckRouteDetailspolylineArgs = {
+    decimals?: Maybe<PolylineInputDecimals>;
+};
+/** Leg of a route detail. */
+export declare type TruckRouteDetailsLeg = {
+    /** Distance from the start to the end of a leg. */
+    distance: Scalars["Float"];
+    /** Aggregation of all durations of a route leg. */
+    durations: RouteDetailsDurations;
+    /** Total energy used in a leg in kilowatt hours. For HEVs and PHEVs this field will return null. */
+    consumption?: Maybe<Scalars["Float"]>;
+    /** Origin point location. */
+    origin: TruckRouteDetailsLegFeaturePoint;
+    /** Destination point location. */
+    destination: TruckRouteDetailsLegFeaturePoint;
+    /** Range at the start of a leg. The ranges in kilometers and miles are estimates, calculated based on the Chargetrip range, current route conditions, weather scenario (current or seasonal), and the route input at the time of planning. For HEVs and PHEVs this field will return null. */
+    range_at_origin?: Maybe<Scalars["Float"]>;
+    /** Range available at the end of a leg. The ranges in kilometers and miles are estimates, calculated based on the Chargetrip range, current route conditions, weather scenario (current or seasonal), and the route input at the time of planning. For HEVs and PHEVs this field will return null. */
+    range_at_destination?: Maybe<Scalars["Float"]>;
+    /** Range after charging on the leg. The ranges in kilometers and miles are estimates, calculated based on the Chargetrip range, current route conditions, weather scenario (current or seasonal), and the route input at the time of planning. For HEVs and PHEVs this field will return null. */
+    range_after_charge?: Maybe<Scalars["Float"]>;
+    /** Type of a leg. */
+    type: RouteDetailsLegType;
+    /** Information about the station at the destination of a leg. */
+    station?: Maybe<RouteDetailsLegStation>;
+    /** Polyline containing encoded coordinates. */
+    polyline: Scalars["String"];
+    /** Aggregation of tags over the current leg. Tags are further subdivided over individual sections and maneuvers. */
+    tags: Array<RouteDetailsTag>;
+    /** Maneuvers of a leg - used to generate turn-by-turn instructions. */
+    maneuvers: Array<RouteDetailsManeuver>;
+    /** Road sections of a leg - divided by means of transportation. */
+    sections: Array<TruckRouteDetailsLegSection>;
+};
+/** Leg of a route detail. */
+export declare type TruckRouteDetailsLegdistanceArgs = {
+    unit?: Maybe<DistanceUnit>;
+};
+/** Leg of a route detail. */
+export declare type TruckRouteDetailsLegrange_at_originArgs = {
+    unit?: Maybe<StateOfChargeUnit>;
+};
+/** Leg of a route detail. */
+export declare type TruckRouteDetailsLegrange_at_destinationArgs = {
+    unit?: Maybe<StateOfChargeUnit>;
+};
+/** Leg of a route detail. */
+export declare type TruckRouteDetailsLegrange_after_chargeArgs = {
+    unit?: Maybe<StateOfChargeUnit>;
+};
+/** Leg of a route detail. */
+export declare type TruckRouteDetailsLegpolylineArgs = {
+    decimals?: Maybe<PolylineInputDecimals>;
+};
+export declare type TruckRouteDetailsLegFeaturePoint = {
+    /** ID of the feature. */
+    id?: Maybe<Scalars["ID"]>;
+    /** Feature type. */
+    type: FeatureType;
+    /** Geometry of the feature. */
+    geometry: Point;
+    /** Properties of the feature. */
+    properties?: Maybe<TruckRouteDetailsLegFeatureProperties>;
+};
+export declare type TruckRouteDetailsLegFeatureProperties = {
+    /** Name of the location. */
+    name?: Maybe<Scalars["String"]>;
+    /** ID of the station. */
+    station_id?: Maybe<Scalars["ID"]>;
+    /** External ID of the station. */
+    external_station_id?: Maybe<Scalars["ID"]>;
+    /** Temperature at the location. */
+    temperature?: Maybe<Scalars["Int"]>;
+    /** Air pressure at the location. */
+    air_pressure?: Maybe<Scalars["Float"]>;
+    /** Solar irradiance at the location. */
+    solar_irradiance?: Maybe<Scalars["Float"]>;
+    /** Duration, in seconds, of time spent at this location. */
+    duration?: Maybe<Scalars["Int"]>;
+    /** Number of occupants present in the vehicle. */
+    occupants: Scalars["Int"];
+    /** Value of the combined weight of the occupants. */
+    total_occupant_weight: Scalars["Float"];
+    /** Value of the current weight of the cargo. */
+    total_cargo_weight?: Maybe<Scalars["Float"]>;
+    /** Number of trailers. */
+    trailer_count: Scalars["Int"];
+};
+export declare type TruckRouteDetailsLegFeaturePropertiestemperatureArgs = {
+    unit?: Maybe<TemperatureUnit>;
+};
+export declare type TruckRouteDetailsLegFeaturePropertiestotal_occupant_weightArgs = {
+    unit?: Maybe<WeightUnit>;
+};
+export declare type TruckRouteDetailsLegFeaturePropertiestotal_cargo_weightArgs = {
+    unit?: Maybe<WeightUnit>;
+};
+export declare type TruckRouteDetailsLegSection = {
+    /** Section type. */
+    type: RouteDetailsLegSectionType;
+    /** Origin point. */
+    origin: TruckRouteDetailsLegSectionFeaturePoint;
+    /** Destination point. */
+    destination: TruckRouteDetailsLegSectionFeaturePoint;
+    /** Aggregation of tags over the current section. */
+    tags: Array<RouteDetailsTag>;
+    /** Polyline containing encoded coordinates. */
+    polyline: Scalars["String"];
+    /** Distance from the start to the end of a section. */
+    distance: Scalars["Float"];
+    /** Total duration of a section, in seconds. The value will be 0 for walking sections. */
+    duration: Scalars["Float"];
+    /** Total energy used in a section in kilowatt-hours. The value will be 0 for walking sections. */
+    consumption?: Maybe<Scalars["Float"]>;
+};
+export declare type TruckRouteDetailsLegSectionpolylineArgs = {
+    decimals?: Maybe<PolylineInputDecimals>;
+};
+export declare type TruckRouteDetailsLegSectiondistanceArgs = {
+    unit?: Maybe<DistanceUnit>;
+};
+export declare type TruckRouteDetailsLegSectionFeaturePoint = {
+    /** ID of the feature. */
+    id?: Maybe<Scalars["ID"]>;
+    /** Feature type. */
+    type: FeatureType;
+    /** Geometry of the feature. */
+    geometry: Point;
+    /** Properties of the feature. */
+    properties: TruckRouteDetailsLegSectionFeaturePointProperties;
+};
+export declare type TruckRouteDetailsLegSectionFeaturePointProperties = {
+    /** Number of occupants present in the vehicle. */
+    occupants: Scalars["Int"];
+    /** Value of the combined weight of the occupants. */
+    total_occupant_weight?: Maybe<Scalars["Float"]>;
+    /** Value of the current weight of the cargo. */
+    total_cargo_weight?: Maybe<Scalars["Float"]>;
+    /** Number of trailers. */
+    trailer_count: Scalars["Int"];
+};
+export declare type TruckRouteDetailsLegSectionFeaturePointPropertiestotal_occupant_weightArgs = {
+    unit?: Maybe<WeightUnit>;
+};
+export declare type TruckRouteDetailsLegSectionFeaturePointPropertiestotal_cargo_weightArgs = {
+    unit?: Maybe<WeightUnit>;
+};
+export declare type TruckRouteResponse = {
+    /** ID of a route calculation. */
+    id: Scalars["ID"];
+    /** Status of a route. */
+    status: RouteStatus;
+    /** Recommended route. */
+    recommended?: Maybe<TruckRouteDetails>;
+    /** Meta data for a route. */
+    meta: RouteMetadata;
+    /** Route request. */
+    request_input: CreateTruckRoute;
+};
+/** Physical dimensions of the vehicle and trailers combination. */
+export declare type TruckTrailerCombinedDimensions = {
+    /** Maximum height of the combination trailer and main vehicle combination (ground to highest vehicle point). */
+    height: Scalars["Float"];
+    /** Maximum width of the trailers and main vehicle combination. */
+    width: Scalars["Float"];
+    /** Total length of the trailers and main vehicle combination (bumper to bumper). */
+    length: Scalars["Float"];
+};
+/** Physical dimensions of the vehicle and trailers combination. */
+export declare type TruckTrailerCombinedDimensionsheightArgs = {
+    unit?: Maybe<MeasurementUnit>;
+};
+/** Physical dimensions of the vehicle and trailers combination. */
+export declare type TruckTrailerCombinedDimensionswidthArgs = {
+    unit?: Maybe<MeasurementUnit>;
+};
+/** Physical dimensions of the vehicle and trailers combination. */
+export declare type TruckTrailerCombinedDimensionslengthArgs = {
+    unit?: Maybe<MeasurementUnit>;
+};
+/** Physical dimensions of the vehicle and trailers combination. */
+export declare type TruckTrailerCombinedDimensionsInput = {
+    /** Maximum height of the combination trailer and main vehicle combination (ground to highest vehicle point). */
+    height: DimensionsInput;
+    /** Maximum width of the trailers and main vehicle combination. */
+    width: DimensionsInput;
+    /** Total length of the trailers and main vehicle combination (bumper to bumper). */
+    length: DimensionsInput;
+};
 export declare enum TurningCircleUnit {
     /** Return the turning circle in meters. */
     METER = "meter",
@@ -7895,6 +8349,12 @@ export declare enum WeatherType {
     /** Must be used in combination with weather.custom object. */
     CUSTOM = "custom"
 }
+export declare type WeightInput = {
+    /** Preferred unit for the weight */
+    type: WeightUnit;
+    /** Value of weight */
+    value: Scalars["Float"];
+};
 export declare enum WeightUnit {
     /** Return the weight in kilograms. */
     KILOGRAM = "kilogram",