@chargetrip/types 1.42.0 → 1.44.0

package/src/graphql.ts

@@ -181,15 +181,25 @@ export type AuthorizeConnectedVehicleOptions = {
   code?: Maybe<Scalars["PlainString"]>;
 };
 
+export type AuxiliaryConsumption = {
+  /** Value of the auxiliary power consumption of the vehicle. */
+  value: Scalars["Float"];
+  /** Type of auxiliary power consumption of the vehicle. */
+  type: AuxiliaryConsumptionUnit;
+  /** Source of inputted data. */
+  source: TelemetryInputSource;
+};
+
 export type AuxiliaryConsumptionInput = {
   /** Value of the auxiliary power consumption of the vehicle. */
   value: Scalars["Float"];
   /** Type of auxiliary power consumption of the vehicle. */
   type: AuxiliaryConsumptionUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
 };
 
+/** Auxiliary consumption units. */
 export enum AuxiliaryConsumptionUnit {
   /** Return the auxiliary consumption in kilowatt hours. */
   KILOWATT_HOUR = "kilowatt_hour"
@@ -1494,15 +1504,25 @@ export enum ChargeMode {
   ALWAYS_TO_MAX_CHARGE = "ALWAYS_TO_MAX_CHARGE"
 }
 
+export type ChargeSpeed = {
+  /** Value of the charge speed of the battery. */
+  value: Scalars["Float"];
+  /** Type of the charge speed of the battery. */
+  type: ChargeSpeedUnit;
+  /** Source of inputted data */
+  source: TelemetryInputSource;
+};
+
 export type ChargeSpeedInput = {
   /** Value of the charge speed of the battery. */
   value: Scalars["Float"];
   /** Type of the charge speed of the battery. */
   type: ChargeSpeedUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
 };
 
+/** Charge speed unit. */
 export enum ChargeSpeedUnit {
   /** Return the charge speed in kilowatt hours. */
   KILOWATT_HOUR = "kilowatt_hour",
@@ -1525,7 +1545,7 @@ export type ChargeTotalInput = {
 export type Charger = {
   /** Type of a charger. */
   standard?: Maybe<ConnectorType>;
-  /** Power of a charger. */
+  /** Power of a charger, in kW. */
   power?: Maybe<Scalars["Float"]>;
   /** Price of a charger. */
   price?: Maybe<Scalars["String"]>;
@@ -1537,6 +1557,7 @@ export type Charger = {
   total?: Maybe<Scalars["Int"]>;
 };
 
+/** Status of a charger. */
 export enum ChargerStatus {
   /** The charger is free. */
   FREE = "free",
@@ -1770,8 +1791,13 @@ export type Connector = {
   properties?: Maybe<Scalars["JSON"]>;
   /** List of valid charging tariffs. */
   tariff?: Maybe<Array<Maybe<OCPITariff>>>;
-  /** Charging prices. */
+  /**
+   * Charging prices.
+   * @deprecated In favor of prices.
+   */
   pricing?: Maybe<Pricing>;
+  /** Dynamic charging prices. */
+  prices?: Maybe<Array<ConnectorPrice>>;
   /** Custom properties of a connector. These are vendor specific and will return null values on the fields that are not supported by your station database. */
   custom_properties?: Maybe<ConnectorCustomProperties>;
 };
@@ -1780,13 +1806,196 @@ export type Connector = {
 export type ConnectorCustomProperties = {
   /**
    * Charging prices.
-   * @deprecated In favor of connector.pricing
+   * @deprecated In favor of connector.prices.
    */
   pricing?: Maybe<Pricing>;
   /** Custom connector properties for OICP databases. Station databases that not follow the OICP standard return null values. */
   oicp?: Maybe<OICPConnectorCustomProperties>;
 };
 
+/** Connector charging price. */
+export type ConnectorPrice = {
+  /** ID for the price. */
+  external_id: Scalars["String"];
+  /** Owner of the payment product. */
+  partner?: Maybe<Scalars["String"]>;
+  /** ID for the owner of the payment product. */
+  partner_id: Scalars["String"];
+  /** Payment product. */
+  product: ConnectorPriceProduct;
+  /** Price product elements. */
+  elements: Array<ConnectorPriceElement>;
+  /** Indicates when the pricing data was last updated. The date is in ISO 8601 standard and the time zone is UTC. The update could be a price update or any other update (for example, pricing type update). */
+  last_updated?: Maybe<Scalars["DateTime"]>;
+};
+
+export type ConnectorPriceElement = {
+  /** Connector price element components. */
+  components: Array<ConnectorPriceElementComponent>;
+  /** Connector price element restrictions. */
+  restrictions?: Maybe<ConnectorPriceElementRestrictions>;
+};
+
+export type ConnectorPriceElementComponent = {
+  /** Type of pricing that is applicable. */
+  type: ConnectorPriceElementComponentType;
+  /** Applicable price excluding VAT. */
+  price_excl_vat: Scalars["Float"];
+  /** Applicable VAT. */
+  vat: Scalars["Float"];
+  /**
+   * 	Indicates the minimum amount that is billed. A
+   * unit is billed in step-size blocks. For example, if the type is TIME and step_size is 300, then the time is billed in blocks of 5 minutes. Hence, if 6 minutes is used, then 10 minutes (2 blocks of step_size) is billed.
+   *
+   * 	Note: step_size also depends on the type. Every type (except FLAT) defines a step_size multiplier. This is the size of every 'step' and the unit. For example, PARKING_TIME has a step-size multiplier of 1 second. Therefore, the step_size of a price component is multiplied by 1 second. Thus, step_size = 300 means 300 seconds.
+   */
+  step_size: Scalars["Int"];
+};
+
+/** Type of pricing that is applicable. */
+export enum ConnectorPriceElementComponentType {
+  /** Price per kWh. */
+  ENERGY = "energy",
+  /** Fixed price per charging session. */
+  FLAT = "flat",
+  /** Parking price per hour. This fee is applicable even if the parked car is not charging. */
+  PARKING_TIME = "parking_time",
+  /** Fixed price per hour. */
+  TIME = "time"
+}
+
+export type ConnectorPriceElementRestrictions = {
+  /** Starting time of the day for the prices. */
+  start_time?: Maybe<Scalars["String"]>;
+  /** Ending time of the day for the prices. */
+  end_time?: Maybe<Scalars["String"]>;
+  /** Starting date for the prices. */
+  start_date?: Maybe<Scalars["String"]>;
+  /** Ending date for the prices. */
+  end_date?: Maybe<Scalars["String"]>;
+  /** Minimum energy used, in kWh. */
+  minimum_kwh?: Maybe<Scalars["Float"]>;
+  /** Maximum energy used, in kWh. */
+  maximum_kwh?: Maybe<Scalars["Float"]>;
+  /** Minimum charging speed, in kW. */
+  minimum_power?: Maybe<Scalars["Float"]>;
+  /** Maximum charging speed, in kW. */
+  maximum_power?: Maybe<Scalars["Float"]>;
+  /** Sum of the minimum current (in Amperes) over all the phases. When the EV is charging with more than or equal to this value the prices are active. If the charging current is lower, this price is inactive. */
+  minimum_current?: Maybe<Scalars["Float"]>;
+  /** Sum of the maximum current (in Amperes) over all the phases. When the EV is charging with less than this value the prices are active. If the charging current is higher, this price is inactive. */
+  maximum_current?: Maybe<Scalars["Float"]>;
+  /** Minimum price based on the amount of kWh that is being delivered. */
+  minimum_price?: Maybe<Scalars["Float"]>;
+  /** Maximum price based on the amount of kWh that is being delivered. */
+  maximum_price?: Maybe<Scalars["Float"]>;
+  /** Battery percentage at which the overstay prices are active. */
+  overstay_battery_percentage?: Maybe<
+    ConnectorPriceRestrictionsOverstayBatteryPercentage
+  >;
+  /** Time after which the overstay prices are active. */
+  overstay_time?: Maybe<ConnectorPriceRestrictionsOverstayTime>;
+  /** Minimum duration, in seconds. */
+  minimum_duration?: Maybe<Scalars["Int"]>;
+  /** Maximum duration, in seconds. */
+  maximum_duration?: Maybe<Scalars["Int"]>;
+  /** Day(s) of the week that the prices are valid. */
+  day_of_week?: Maybe<Array<DayOfWeek>>;
+  /** Contract signed between the eMSP and the customer. */
+  emsp_contract_date?: Maybe<ConnectorPriceRestrictionsEmspContractDate>;
+  /**
+   * When this field is present, the ConnectorPriceElement describes reservation costs.
+   * A reservation starts when the reservation is made, and ends when the driver starts charging on the reserved EVSE/Location,
+   * or when the reservation expires. A reservation can only have: `flat` and `time` ConnectorPriceElementComponentType,
+   * where time is for the duration of the reservation.
+   *
+   * When a price has both, `reservation` and `reservation_expires` ConnectorPriceElement,
+   * where both ConnectorPriceElement have a time ConnectorPriceElementComponent,
+   * then the time based cost of an expired reservation will be calculated based on the `reservation_expires` ConnectorPriceElement.
+   */
+  reservation?: Maybe<ConnectorPriceRestrictionsReservationType>;
+};
+
+/** Payment product. */
+export type ConnectorPriceProduct = {
+  /** Name of the payment product. */
+  name: Scalars["String"];
+  /** Type of the payment product. */
+  type: ConnectorPriceProductType;
+  /** A brief description of the product. */
+  description: Scalars["String"];
+  /** Indicates the type of subscription. */
+  subscription_type: ConnectorPriceProductSubscriptionType;
+  /** Subscription price for a month or year, excluding VAT, if applicable. */
+  subscription_fee_excl_vat: Scalars["Float"];
+  /** Three-digit currency code of the country where the charging station is located. */
+  currency: CurrencyUnit;
+};
+
+/** Type of the payment product. */
+export enum ConnectorPriceProductSubscriptionType {
+  /** The subscription fee is applicable every month. */
+  MONTHLY = "monthly",
+  /** The subscription fee is applicable every year. */
+  YEARLY = "yearly",
+  /** An initial fee is applicable to purchase a RFID card or chip, but there isn't a recurring subscription fee. */
+  ONE_OFF = "one_off",
+  /** The product doesn’t have a subscription option. */
+  NOT_APPLICABLE = "not_applicable"
+}
+
+/** Type of the payment product. */
+export enum ConnectorPriceProductType {
+  AD_HOC = "ad_hoc",
+  MSP = "msp",
+  CPO_SUBSCRIPTION = "cpo_subscription"
+}
+
+export type ConnectorPriceRestrictionsEmspContractDate = {
+  /** Name of the contract signed between the eMSP and a customer. */
+  name?: Maybe<Scalars["String"]>;
+  /** Prices are active from this date, which is based on the contract signed between the eMSP and a customer. */
+  from?: Maybe<Scalars["String"]>;
+  /** Prices are active until this date, which is based on the contract signed between the eMSP and a customer. */
+  to?: Maybe<Scalars["String"]>;
+};
+
+export type ConnectorPriceRestrictionsOverstayBatteryPercentage = {
+  /** Battery percentage at which the overstay prices are active. */
+  minimum?: Maybe<Scalars["Int"]>;
+  /** Battery percentage at which the overstay prices are inactive. */
+  maximum?: Maybe<Scalars["Int"]>;
+  /** Unit for the time after which the prices are active. */
+  unit?: Maybe<ConnectorPriceRestrictionsOverstayTimeUnit>;
+};
+
+export type ConnectorPriceRestrictionsOverstayTime = {
+  /** Time at which the overstay prices are active. */
+  minimum?: Maybe<Scalars["Int"]>;
+  /** Time at which the overstay prices are inactive. */
+  maximum?: Maybe<Scalars["Int"]>;
+  /** Unit for the time after which the prices are active. */
+  unit?: Maybe<ConnectorPriceRestrictionsOverstayTimeUnit>;
+};
+
+/** The unit of time after which the overstay restrictions are applicable. */
+export enum ConnectorPriceRestrictionsOverstayTimeUnit {
+  /** The overstay restrictions are applicable after a certain number of seconds. */
+  SECONDS = "seconds",
+  /** The overstay restrictions are applicable after a certain number of minutes. */
+  MINUTES = "minutes",
+  /** The overstay restrictions are applicable after a certain number of hours. */
+  HOURS = "hours"
+}
+
+/** Describes the cost associated with reserving a charging station. */
+export enum ConnectorPriceRestrictionsReservationType {
+  /** Describes costs for a reservation. */
+  RESERVATION = "reservation",
+  /** Describes costs for a reservation that expires (i.e. driver does not start a charging session before expiry date of the reservation). */
+  RESERVATION_EXPIRES = "reservation_expires"
+}
+
 /** The socket or plug standard of the charging point. */
 export enum ConnectorType {
   /** The connector type is CHAdeMO, DC. */
@@ -2175,6 +2384,45 @@ export type CreateConnectedVehicleOptions = {
   scope?: Maybe<Array<ConnectScope>>;
 };
 
+export type CreateRoute = {
+  /** Vehicle used on a route. */
+  vehicle: RouteVehicle;
+  /** Origin of a route. */
+  origin: RouteOriginFeaturePoint;
+  /** Destination of a route. */
+  destination: RouteDestinationFeaturePoint;
+  /** Via points of a route. */
+  via?: Maybe<Array<RouteViaFeaturePoint>>;
+  /** Operator preferences for a route. When provided, prefers routes that use higher order operators. */
+  operators?: Maybe<RouteOperatorPreferences>;
+  /** Season of a route. */
+  season: RouteSeason;
+  /** Alternative stations along a route within a specified radius in meters (minimum 500, maximum 5000). */
+  alternative_station_radius?: Maybe<Scalars["Int"]>;
+  /** Departure time of a route. */
+  departure_time?: Maybe<Scalars["DateTime"]>;
+};
+
+/** Input for the create route mutation. */
+export type CreateRouteInput = {
+  /** Vehicle specific input. */
+  vehicle: RouteVehicleInput;
+  /** Origin of a route. */
+  origin: RouteOriginFeaturePointInput;
+  /** Destination of a route. */
+  destination: RouteDestinationFeaturePointInput;
+  /** Optional via points of a route. */
+  via?: Maybe<Array<RouteViaFeaturePointInput>>;
+  /** Prioritized operators for a route calculation. */
+  operators?: Maybe<RouteOperatorPreferencesInput>;
+  /** Optional flag to specify the season. */
+  season?: Maybe<RouteSeason>;
+  /** Alternative stations along a route within a specified radius in meters (minimum 500, maximum 5000). */
+  alternative_station_radius?: Maybe<Scalars["Int"]>;
+  /** Route departure time. */
+  departure_time?: Maybe<Scalars["DateTime"]>;
+};
+
 /** Currency according to the ISO 4217 standard. */
 export enum CurrencyUnit {
   /** Return the currency in EUR. */
@@ -2182,7 +2430,149 @@ export enum CurrencyUnit {
   /** Return the currency in USD. */
   USD = "USD",
   /** Return the currency in GBP. */
-  GBP = "GBP"
+  GBP = "GBP",
+  AED = "AED",
+  AFN = "AFN",
+  ALL = "ALL",
+  AMD = "AMD",
+  ANG = "ANG",
+  AOA = "AOA",
+  ARS = "ARS",
+  AUD = "AUD",
+  AWG = "AWG",
+  AZN = "AZN",
+  BAM = "BAM",
+  BBD = "BBD",
+  BDT = "BDT",
+  BGN = "BGN",
+  BIF = "BIF",
+  BMD = "BMD",
+  BND = "BND",
+  BOB = "BOB",
+  BRL = "BRL",
+  BSD = "BSD",
+  BWP = "BWP",
+  BYN = "BYN",
+  BZD = "BZD",
+  CAD = "CAD",
+  CDF = "CDF",
+  CHF = "CHF",
+  CLP = "CLP",
+  CNY = "CNY",
+  COP = "COP",
+  CRC = "CRC",
+  CVE = "CVE",
+  CZK = "CZK",
+  DJF = "DJF",
+  DKK = "DKK",
+  DOP = "DOP",
+  DZD = "DZD",
+  EGP = "EGP",
+  ETB = "ETB",
+  FJD = "FJD",
+  FKP = "FKP",
+  GEL = "GEL",
+  GIP = "GIP",
+  GMD = "GMD",
+  GNF = "GNF",
+  GTQ = "GTQ",
+  GYD = "GYD",
+  HKD = "HKD",
+  HNL = "HNL",
+  HTG = "HTG",
+  HUF = "HUF",
+  IDR = "IDR",
+  ILS = "ILS",
+  INR = "INR",
+  ISK = "ISK",
+  JMD = "JMD",
+  JPY = "JPY",
+  KES = "KES",
+  KGS = "KGS",
+  KHR = "KHR",
+  KMF = "KMF",
+  KRW = "KRW",
+  KYD = "KYD",
+  KZT = "KZT",
+  LAK = "LAK",
+  LBP = "LBP",
+  LKR = "LKR",
+  LRD = "LRD",
+  LSL = "LSL",
+  MAD = "MAD",
+  MDL = "MDL",
+  MGA = "MGA",
+  MKD = "MKD",
+  MMK = "MMK",
+  MNT = "MNT",
+  MOP = "MOP",
+  MUR = "MUR",
+  MVR = "MVR",
+  MWK = "MWK",
+  MXN = "MXN",
+  MYR = "MYR",
+  MZN = "MZN",
+  NAD = "NAD",
+  NGN = "NGN",
+  NIO = "NIO",
+  NOK = "NOK",
+  NPR = "NPR",
+  NZD = "NZD",
+  PAB = "PAB",
+  PEN = "PEN",
+  PGK = "PGK",
+  PHP = "PHP",
+  PKR = "PKR",
+  PLN = "PLN",
+  PYG = "PYG",
+  QAR = "QAR",
+  RON = "RON",
+  RSD = "RSD",
+  RUB = "RUB",
+  RWF = "RWF",
+  SAR = "SAR",
+  SBD = "SBD",
+  SCR = "SCR",
+  SEK = "SEK",
+  SGD = "SGD",
+  SHP = "SHP",
+  SLE = "SLE",
+  SOS = "SOS",
+  SRD = "SRD",
+  STD = "STD",
+  SZL = "SZL",
+  THB = "THB",
+  TJS = "TJS",
+  TOP = "TOP",
+  TRY = "TRY",
+  TTD = "TTD",
+  TWD = "TWD",
+  TZS = "TZS",
+  UAH = "UAH",
+  UGX = "UGX",
+  UYU = "UYU",
+  UZS = "UZS",
+  VND = "VND",
+  VUV = "VUV",
+  WST = "WST",
+  XAF = "XAF",
+  XCD = "XCD",
+  XOF = "XOF",
+  XPF = "XPF",
+  YER = "YER",
+  ZAR = "ZAR",
+  ZMW = "ZMW"
+}
+
+/** Represents a day of the week. */
+export enum DayOfWeek {
+  MONDAY = "monday",
+  TUESDAY = "tuesday",
+  WEDNESDAY = "wednesday",
+  THURSDAY = "thursday",
+  FRIDAY = "friday",
+  SATURDAY = "saturday",
+  SUNDAY = "sunday"
 }
 
 export enum DimensionUnit {
@@ -2196,14 +2586,15 @@ export enum DimensionUnit {
   MILE = "mile"
 }
 
+/** Distance unit */
 export enum DistanceUnit {
-  /** Return the distance in meters */
+  /** Return the distance in meters. */
   METER = "meter",
-  /** Return the distance in feet */
+  /** Return the distance in feet. */
   FOOT = "foot",
-  /** Return the distance in kilometers */
+  /** Return the distance in kilometers. */
   KILOMETER = "kilometer",
-  /** Return the distance in miles */
+  /** Return the distance in miles. */
   MILE = "mile"
 }
 
@@ -2246,6 +2637,17 @@ export type EVSE = {
   custom_properties?: Maybe<EvseCustomProperties>;
 };
 
+export type ElectricityGenerationMethod = {
+  /** Fraction of total electricity production. */
+  fraction: Scalars["Float"];
+  /** Emissions per kWh of the generation method. */
+  intensity: Scalars["Float"];
+};
+
+export type ElectricityGenerationMethodintensityArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
 export type ElevationInput = {
   /** Value of the elevation. */
   value: Scalars["Float"];
@@ -2276,6 +2678,22 @@ export enum EmissionUnit {
   OUNCE = "ounce"
 }
 
+export type EmissionsFactor = {
+  /** The name of the area for which the emissions factor was calculated. */
+  name: Scalars["String"];
+  /** The type of area for which the emissions factor was calculated. */
+  type: EmissionsFactorType;
+  /** The base regional emissions factor in CO2e/kWh. */
+  value: Scalars["Float"];
+};
+
+/** Emissions factor type. */
+export enum EmissionsFactorType {
+  COUNTRY = "country",
+  SUBREGION = "subregion",
+  REGION = "region"
+}
+
 /** Custom EVSE properties for OICP databases such as the global Hubject database. Station databases that not follow the OICP standard return null values. */
 export type EvseCustomProperties = {
   /** OICP standard custom properties. */
@@ -2361,6 +2779,60 @@ export enum FeatureType {
   FEATURE = "Feature"
 }
 
+export type FluidEndOfLifeEmissions = {
+  /** Total fluid end of life emissions. */
+  total: Scalars["Float"];
+  /** Wiper fluid end of life emissions. */
+  wiper: Scalars["Float"];
+  /** Brake fluid end of life emissions. */
+  brake: Scalars["Float"];
+  /** Powertrain coolant fluid end of life emissions. */
+  powertrain_coolant: Scalars["Float"];
+  /** Transmission fluid end of life emissions. */
+  transmission: Scalars["Float"];
+  /** Motor oil end of life emissions. */
+  motor_oil?: Maybe<Scalars["Float"]>;
+};
+
+export type FluidEndOfLifeEmissionstotalArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type FluidEndOfLifeEmissionswiperArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type FluidEndOfLifeEmissionsbrakeArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type FluidEndOfLifeEmissionspowertrain_coolantArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type FluidEndOfLifeEmissionstransmissionArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type FluidEndOfLifeEmissionsmotor_oilArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type FluidMaintenanceEmissions = {
+  /** Total fluid maintenance emissions. */
+  total: RouteOperationalMaintenanceEmissionsField;
+  /** Wiper fluid maintenance emissions. */
+  wiper: RouteOperationalMaintenanceEmissionsField;
+  /** Brake fluid maintenance emissions. */
+  brake: RouteOperationalMaintenanceEmissionsField;
+  /** Powertrain coolant fluid maintenance emissions. */
+  powertrain_coolant: RouteOperationalMaintenanceEmissionsField;
+  /** Transmission fluid maintenance emissions. */
+  transmission: RouteOperationalMaintenanceEmissionsField;
+  /** Motor oil maintenance emissions. */
+  motor_oil?: Maybe<RouteOperationalMaintenanceEmissionsField>;
+};
+
 export enum FuelConsumptionUnit {
   /** Return the fuel consumption in liters per 100 kilometers. */
   LITERS_PER_100_KILOMETERS = "liters_per_100_kilometers",
@@ -2381,6 +2853,7 @@ export type GeometryPoint = {
   coordinates: Array<Scalars["Float"]>;
 };
 
+/** Mode of heat pump. */
 export enum HeatPumpMode {
   /** Default to the vehicle configuration. */
   DEFAULT = "default",
@@ -2488,9 +2961,9 @@ export type IsolineInput = {
   quality?: Maybe<IsolineQuality>;
   /** Include ferry connections. Single and multiple ferry connections increase the calculation time and the number of polygons. */
   ferry_connections?: Maybe<IsolineFerryConnectionsType>;
-  /** Battery state of charge. When omitted the default value is 100 percent. */
+  /** Battery state of charge. Default is usable battery kwh of the inputted vehicle. */
   state_of_charge?: Maybe<StateOfChargeInput>;
-  /** Minimum final battery state of charge. When omitted the default value is 0 percent. */
+  /** Minimum final battery state of charge. Default is 0 */
   final_state_of_charge?: Maybe<StateOfChargeInput>;
 };
 
@@ -2658,6 +3131,8 @@ export type Mutation = {
    * This is a premium feature, contact Chargetrip for more information.
    */
   deleteUserReview: Review;
+  /** [BETA] Create a new route from the route input and its ID. */
+  createRoute: Scalars["ID"];
   /** Create a new route from the route input and its ID */
   newRoute?: Maybe<Scalars["ID"]>;
 };
@@ -2706,6 +3181,10 @@ export type MutationdeleteUserReviewArgs = {
   id: Scalars["ID"];
 };
 
+export type MutationcreateRouteArgs = {
+  input: CreateRouteInput;
+};
+
 export type MutationnewRouteArgs = {
   input?: Maybe<RequestInput>;
 };
@@ -2752,7 +3231,7 @@ export type NavigationInstructionsInput = {
   instructions_format: InstructionsFormat;
   /** Preferred navigation instructions language. Default: en */
   language?: Maybe<MappingLanguage>;
-  /** Number of decimals used for the Google Polyline encoding Algorithm. Allowed values are 5 or 6, the default is 5 */
+  /** Number of decimals used for the Google Polyline encoding Algorithm. Allowed values are 5 or 6. */
   precision?: Maybe<Scalars["Int"]>;
 };
 
@@ -3051,9 +3530,9 @@ export type OCPIEnvironmentalImpact = {
 
 /** Categories of environmental impact values. */
 export enum OCPIEnvironmentalImpactCategory {
-  /** Produced nuclear waste in grams per kilowatthour. */
+  /** Produced nuclear waste in g/kWh. */
   NUCLEAR_WASTE = "NUCLEAR_WASTE",
-  /** Exhausted carbon dioxide in grams per kilowatthour. */
+  /** Exhausted carbon dioxide in g/kWh. */
   CARBON_DIOXIDE = "CARBON_DIOXIDE"
 }
 
@@ -3447,13 +3926,22 @@ export enum OICPValueAddedServices {
   NONE = "none"
 }
 
+export type Odometer = {
+  /** Value of the vehicle's odometer. */
+  value: Scalars["Float"];
+  /** Type of the value of the vehicle's odometer. */
+  type: DistanceUnit;
+  /** Source of inputted data. */
+  source: TelemetryInputSource;
+};
+
 export type OdometerInput = {
   /** Value of the vehicle's odometer. */
   value: Scalars["Float"];
   /** Type of the value of the vehicle's odometer. */
   type: DistanceUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
 };
 
 /** Operator data which extends OCPI BusinessDetails. */
@@ -3505,6 +3993,13 @@ export type OperatorListQuery = {
   country?: Maybe<Scalars["String"]>;
 };
 
+/** Operator ranking level. */
+export enum OperatorRankingLevel {
+  LOW = "low",
+  MEDIUM = "medium",
+  HIGH = "high"
+}
+
 export type OutsideTempInput = {
   /** Value of the outside temperature. */
   value: Scalars["Float"];
@@ -3565,6 +4060,12 @@ export type PolygonProperties = {
   index?: Maybe<Scalars["Int"]>;
 };
 
+/** Number of decimals for a polyline. */
+export enum PolylineInputDecimals {
+  FIVE = "five",
+  SIX = "six"
+}
+
 export type PowerInput = {
   /** Value of the positive or negative power. When negative the vehicle is charging. */
   value: Scalars["Float"];
@@ -3606,6 +4107,7 @@ export enum PowerUnit {
   HORSEPOWER = "horsepower"
 }
 
+/** Pressure units. */
 export enum PressureUnit {
   /** Return the pressure in bar. */
   BAR = "bar",
@@ -3681,11 +4183,11 @@ export type Query = {
   isoline?: Maybe<Isoline>;
   /** [BETA] Get a navigation session by ID */
   navigation?: Maybe<Navigation>;
-  /** Get a full list of operators */
+  /** Get a full list of operators. */
   operatorList?: Maybe<Array<Maybe<Operator>>>;
-  /** Get information about an operator by its ID */
+  /** Get information about an operator by its ID. */
   operator?: Maybe<Operator>;
-  /** Get all reviews of a station by the station ID */
+  /** Get all reviews of a station by the station ID. */
   reviewList?: Maybe<Array<Review>>;
   /**
    * Get all reviews of stations that were added by an authenticated user.
@@ -3695,7 +4197,11 @@ export type Query = {
   userReviewList?: Maybe<Array<Review>>;
   /** Get a route by ID */
   route?: Maybe<Route>;
-  /** [BETA] Emissions profile for route. */
+  /** [BETA] Get a route by ID. */
+  getRoute: RouteResponse;
+  /** [BETA] Get emissions for a route. */
+  getRouteEmissions: RouteDetailsEmissions;
+  /** Emissions profile for route. */
   routeEmissions: RouteEmissions;
   /** Retrieve information about a route path segment */
   routePath?: Maybe<RoutePath>;
@@ -3707,12 +4213,10 @@ export type Query = {
   stationList?: Maybe<Array<Maybe<Station>>>;
   /** Search for stations around a GeoJSON point with a specific distance in meters. */
   stationAround?: Maybe<Array<Maybe<Station>>>;
-  /** Get information about a tariff by the tariff ID */
+  /** Get information about a tariff by the tariff ID. */
   tariff?: Maybe<OCPITariff>;
-  /** Get the full list of tariffs */
+  /** Get the full list of tariffs. */
   tariffList?: Maybe<Array<Maybe<OCPITariff>>>;
-  /** Deprecated: This query will be removed in favor of navigation query and subscription. Mapping can be retrieved via the instructions field. */
-  navigationMapping?: Maybe<Scalars["JSON"]>;
   /** Get information about a vehicle by its ID. */
   vehicle?: Maybe<Vehicle>;
   /** Vehicle premium data provides even more information about your vehicle: tire pressure, prices, drivetrain data, and more. Please contact us for access to premium data. */
@@ -3791,6 +4295,15 @@ export type QueryrouteArgs = {
   id: Scalars["ID"];
 };
 
+export type QuerygetRouteArgs = {
+  id: Scalars["ID"];
+};
+
+export type QuerygetRouteEmissionsArgs = {
+  route_id: Scalars["ID"];
+  route_details_id: Scalars["ID"];
+};
+
 export type QueryrouteEmissionsArgs = {
   route_id: Scalars["ID"];
   route_alternative_id?: Maybe<Scalars["ID"]>;
@@ -3832,13 +4345,6 @@ export type QuerytariffListArgs = {
   page?: Maybe<Scalars["Int"]>;
 };
 
-export type QuerynavigationMappingArgs = {
-  id: Scalars["ID"];
-  provider: MappingProvider;
-  precision?: Maybe<Scalars["Int"]>;
-  language?: Maybe<MappingLanguage>;
-};
-
 export type QueryvehicleArgs = {
   id: Scalars["ID"];
   country?: Maybe<CountryCodeAlpha2>;
@@ -3874,7 +4380,7 @@ export type RequestEv = {
   adapters?: Maybe<Array<Maybe<RequestEvPlug>>>;
   /** Minimum desired power of chargers. */
   minPower?: Maybe<Scalars["Int"]>;
-  /** Climate is on. The default is true. */
+  /** Climate is on. */
   climate?: Maybe<Scalars["Boolean"]>;
   /** Vehicle Heat Pump configuration. */
   heatPump?: Maybe<HeatPumpMode>;
@@ -3953,7 +4459,7 @@ export type RequestEvCabinInput = {
 };
 
 export type RequestEvConsumption = {
-  /** The amount of energy, in kWh, used by the auxiliary systems of the vehicle in a hour, like media box, etc */
+  /** The amount of energy, in kWh, used by the auxiliary systems of the vehicle in an hour, like media box, etc */
   auxiliary?: Maybe<Scalars["Float"]>;
   /**
    * Consumption, in kWh, of the auxiliaries.
@@ -3973,7 +4479,7 @@ export type RequestEvConsumption = {
 };
 
 export type RequestEvConsumptionInput = {
-  /** The amount of energy, in kWh, used by the auxiliary systems of the vehicle in a hour, like media box, etc. */
+  /** The amount of energy, in kWh, used by the auxiliary systems of the vehicle in an hour, like media box, etc. */
   auxiliary?: Maybe<Scalars["Float"]>;
   /** Deprecated in favor of auxiliary. */
   aux?: Maybe<CarConsumptionInput>;
@@ -3994,7 +4500,7 @@ export type RequestEvInput = {
   adapters?: Maybe<Array<Maybe<RequestEvPlugInput>>>;
   /** Minimum desired power of chargers. */
   minPower?: Maybe<Scalars["Int"]>;
-  /** Flag which indicates if the climate is on. The default is true. */
+  /** Flag which indicates if the climate is on. */
   climate?: Maybe<Scalars["Boolean"]>;
   /** Vehicle Heat Pump configuration. */
   heatPump?: Maybe<HeatPumpMode>;
@@ -4062,7 +4568,7 @@ export type RequestRoute = {
   operators?: Maybe<RouteOperators>;
   /** Season. */
   season?: Maybe<RouteSeason>;
-  /** Percentage for the minimum limit of the battery capacity before a recharge. The value should be between 0 and 60, with a default of 10%. */
+  /** Percentage for the minimum limit of the battery capacity before a recharge. The value should be between 0 and 60. When omitted, the project configuration is used. */
   safeRiskMargin?: Maybe<Scalars["Int"]>;
   /** Origin of a route. */
   origin?: Maybe<FeaturePoint>;
@@ -4093,7 +4599,7 @@ export type RequestRouteInput = {
   operators?: Maybe<RouteOperatorsInput>;
   /** Optional flag to specify the season. */
   season?: Maybe<RouteSeason>;
-  /** Percentage for a minimum limit of a battery capacity before a recharge. The value should be between 0 and 60, with a default of 10%. */
+  /** Percentage for a minimum limit of a battery capacity before a recharge. The value should be between 0 and 60. When omitted, the project configuration is used. */
   safeRiskMargin?: Maybe<Scalars["Int"]>;
   /** Mode that indicates if we optimize the charging time or always charge to the maximum capacity. */
   chargeMode?: Maybe<ChargeMode>;
@@ -4129,7 +4635,7 @@ export type Review = {
   /** Locale of a message. */
   locale?: Maybe<Scalars["String"]>;
   /** Vehicle that was provided/selected by a user. */
-  ev?: Maybe<Car>;
+  ev?: Maybe<Vehicle>;
   /** Plug type that was provided/selected by a user. */
   plugType?: Maybe<ConnectorType>;
   /** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer. */
@@ -4349,188 +4855,607 @@ export type RouteApp = {
   id?: Maybe<Scalars["ID"]>;
 };
 
-export type RouteEmbeddedEmissions = {
-  /** Total embedded emissions. */
-  total: Scalars["Float"];
-  /** Total manufacturing emissions. */
-  manufacturing: RouteEmbeddedManufacturingEmissions;
-  /** Total distribution related emissions. */
-  distribution: Scalars["Float"];
-  /** Distribution sea segment emissions. */
-  maritime: RouteEmbeddedMaritimeEmissions;
-  /** Distribution land segment emissions. */
-  land: RouteEmbeddedLandEmissions;
-};
-
-export type RouteEmbeddedEmissionstotalArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
-export type RouteEmbeddedEmissionsdistributionArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
-export type RouteEmbeddedLandEmissions = {
-  /** Total embedded land emissions. */
-  total: Scalars["Float"];
-  /** Distribution land segment emissions from fuel consumption. */
-  fuel: Scalars["Float"];
-  /** Distribution land segment lifecycle emissions. */
-  lifecycle: Scalars["Float"];
-};
-
-export type RouteEmbeddedLandEmissionstotalArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDestinationFeaturePoint = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: Point;
+  /** Optional object where additional properties can be specified. */
+  properties?: Maybe<RouteDestinationProperties>;
 };
 
-export type RouteEmbeddedLandEmissionsfuelArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDestinationFeaturePointInput = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: PointInput;
+  /** Optional object where additional properties can be specified. */
+  properties?: Maybe<RouteDestinationPropertiesInput>;
 };
 
-export type RouteEmbeddedLandEmissionslifecycleArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDestinationProperties = {
+  /** Data about the destination location. */
+  location?: Maybe<RoutePropertiesLocation>;
+  /** Data about the destination station. */
+  station?: Maybe<RoutePropertiesStation>;
 };
 
-export type RouteEmbeddedManufacturingEmissions = {
-  /** Total embedded manufacturing emissions. */
-  total: Scalars["Float"];
-  /** Body manufacturing emissions. */
-  body: Scalars["Float"];
-  /** Lithium ion battery manufacturing emissions. */
-  battery?: Maybe<Scalars["Float"]>;
+export type RouteDestinationPropertiesInput = {
+  /** Data about the destination location. */
+  location?: Maybe<RoutePropertiesLocationInput>;
+  /** Data about the destination station. */
+  station?: Maybe<RoutePropertiesStationInput>;
 };
 
-export type RouteEmbeddedManufacturingEmissionstotalArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetails = {
+  /** 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. */
+  consumption: Scalars["Float"];
+  /** Range available at the beginning of a trip. */
+  range_at_origin: Scalars["Float"];
+  /** Range available at the end of a trip. */
+  range_at_destination: Scalars["Float"];
+  /** Text information about a route direction. */
+  via?: Maybe<Scalars["String"]>;
+  /** Polyline containing encoded coordinates. */
+  polyline?: Maybe<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<RouteDetailsLeg>;
+  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 charges along a route. */
+  charges: Scalars["Int"];
 };
 
-export type RouteEmbeddedManufacturingEmissionsbodyArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetailsdistanceArgs = {
+  unit?: Maybe<DistanceUnit>;
 };
 
-export type RouteEmbeddedManufacturingEmissionsbatteryArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetailsrange_at_originArgs = {
+  unit?: Maybe<StateOfChargeUnit>;
 };
 
-export type RouteEmbeddedMaritimeEmissions = {
-  /** Total embedded maritime emissions. */
-  total: Scalars["Float"];
-  /** Fuel related sea segment emissions. */
-  fuel: Scalars["Float"];
-  /** Port facility related sea segment emissions. */
-  port: Scalars["Float"];
-  /** Idling related sea segment emissions. */
-  idle: Scalars["Float"];
-  /** Distributed lifecycle related sea segment emissions. */
-  lifecycle: Scalars["Float"];
+export type RouteDetailsrange_at_destinationArgs = {
+  unit?: Maybe<StateOfChargeUnit>;
 };
 
-export type RouteEmbeddedMaritimeEmissionstotalArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetailspolylineArgs = {
+  decimals: PolylineInputDecimals;
 };
 
-export type RouteEmbeddedMaritimeEmissionsfuelArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetailsAlternativeStation = {
+  /** ID of a station. */
+  id: Scalars["ID"];
+  /** GeoJSON location of a station. */
+  location: Point;
+  /** Speed of a station. A station along a route can be either fast or turbo. */
+  speed: StationSpeedType;
+  /** Status of a station. */
+  status: ChargerStatus;
+  /** Ranking of an operator. */
+  operator_ranking?: Maybe<OperatorRankingLevel>;
+};
+
+/** Aggregation of all durations of a route. */
+export type RouteDetailsDurations = {
+  /** Total duration, in seconds. */
+  total: Scalars["Int"];
+  /** Total duration charging, in seconds. */
+  charging: Scalars["Int"];
+  /** Total duration driving, in seconds. */
+  driving: Scalars["Int"];
+  /** Total duration stopped for a short stay, for example at a via point, in seconds. */
+  stopover: Scalars["Int"];
+  /** Total duration of ferry rides, in seconds. */
+  ferry?: Maybe<Scalars["Int"]>;
+};
+
+export type RouteDetailsElevation = {
+  /** Total value driving uphill on a route. */
+  up: Scalars["Float"];
+  /** Total value driving downhill on a route. */
+  down: Scalars["Float"];
+  /** Maximum elevation on a route. */
+  maximum: Scalars["Float"];
+  /** Minimum elevation on a route. */
+  minimum: Scalars["Float"];
+};
+
+export type RouteDetailsElevationupArgs = {
+  unit?: Maybe<DistanceUnit>;
 };
 
-export type RouteEmbeddedMaritimeEmissionsportArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetailsElevationdownArgs = {
+  unit?: Maybe<DistanceUnit>;
 };
 
-export type RouteEmbeddedMaritimeEmissionsidleArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetailsElevationmaximumArgs = {
+  unit?: Maybe<DistanceUnit>;
 };
 
-export type RouteEmbeddedMaritimeEmissionslifecycleArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteDetailsElevationminimumArgs = {
+  unit?: Maybe<DistanceUnit>;
 };
 
-export type RouteEmissions = {
+export type RouteDetailsEmissions = {
   /** ID of the route for which we retrieve the emissions profile. */
   route_id: Scalars["ID"];
-  /** ID of the route alternative for which we retrieve the emissions profile. */
   route_alternative_id: Scalars["ID"];
   /** Emissions profile for the vehicle used in route. */
   route_vehicle: RouteVehicleEmissions;
-  /** Emissions profile for an equivalent internal combustion engine vehicle. */
   internal_combustion_vehicle: RouteInternalCombustionVehicleEmissions;
+  /** Estimated GHG emissions saved by a user driving this route with the electric vehicle in grams of CO2e. */
+  co2e_saved: Scalars["Float"];
 };
 
-export type RouteEmissionsinternal_combustion_vehicleArgs = {
+export type RouteDetailsEmissionsinternal_combustion_vehicleArgs = {
   fuel_type?: Maybe<RouteOperationalFuelType>;
 };
 
-export type RouteEndOfLifeEmissions = {
-  /** Total end of life emissions. */
-  total: Scalars["Float"];
-  /** Total fluid related end of life emissions. */
-  fluids: RouteEndOfLifeFluidsEmissions;
-  /** Battery related end of life emissions. */
-  battery: Scalars["Float"];
-  /** Tire related end of life emissions. */
-  tires: Scalars["Float"];
-  /** Body end of life emissions. */
-  body: Scalars["Float"];
-  /** Transport end of life emissions. */
-  transport: Scalars["Float"];
+export type RouteDetailsEmissionsco2e_savedArgs = {
+  unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteEndOfLifeEmissionstotalArgs = {
-  unit?: Maybe<EmissionUnit>;
+/** Leg of a route detail. */
+export type RouteDetailsLeg = {
+  /** 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. */
+  consumption: Scalars["Float"];
+  /** Origin point location. */
+  origin: RouteDetailsLegFeaturePoint;
+  /** Destination point location. */
+  destination: RouteDetailsLegFeaturePoint;
+  /** Range at the origin of the leg. */
+  range_at_origin: Scalars["Float"];
+  /** Range at the destination of the leg. */
+  range_at_destination: Scalars["Float"];
+  /** Range after charging on the leg. */
+  range_after_charge?: Maybe<Scalars["Float"]>;
+  /** Type of a leg. */
+  type: RouteDetailsLegType;
+  /** Name of a destination. This is the station name in case a user should charge or the name of the location in case this was provided. */
+  name?: Maybe<Scalars["String"]>;
+  /** Information about the station at the origin of this 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<RouteDetailsLegSection>;
 };
 
-export type RouteEndOfLifeEmissionsbatteryArgs = {
-  unit?: Maybe<EmissionUnit>;
+/** Leg of a route detail. */
+export type RouteDetailsLegdistanceArgs = {
+  unit?: Maybe<DistanceUnit>;
 };
 
-export type RouteEndOfLifeEmissionstiresArgs = {
-  unit?: Maybe<EmissionUnit>;
+/** Leg of a route detail. */
+export type RouteDetailsLegrange_at_originArgs = {
+  unit?: Maybe<StateOfChargeUnit>;
 };
 
-export type RouteEndOfLifeEmissionsbodyArgs = {
-  unit?: Maybe<EmissionUnit>;
+/** Leg of a route detail. */
+export type RouteDetailsLegrange_at_destinationArgs = {
+  unit?: Maybe<StateOfChargeUnit>;
 };
 
-export type RouteEndOfLifeEmissionstransportArgs = {
-  unit?: Maybe<EmissionUnit>;
+/** Leg of a route detail. */
+export type RouteDetailsLegrange_after_chargeArgs = {
+  unit?: Maybe<StateOfChargeUnit>;
 };
 
-export type RouteEndOfLifeFluidsEmissions = {
-  /** Total end of life fluids emissions. */
-  total: Scalars["Float"];
-  /** Total wiper fluid end of life emissions. */
-  wiper: Scalars["Float"];
-  /** Total brake fluid end of life emissions. */
-  brake: Scalars["Float"];
-  /** Total powertrain coolant fluid end of life emissions. */
-  coolant: Scalars["Float"];
-  /** Total transmission fluid end of life emissions. */
-  transmission: Scalars["Float"];
-  /** Total motor oil end of life emissions. */
-  motor_oil?: Maybe<Scalars["Float"]>;
+/** Leg of a route detail. */
+export type RouteDetailsLegpolylineArgs = {
+  decimals: PolylineInputDecimals;
+};
+
+export type RouteDetailsLegFeaturePoint = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: Point;
+  /** Properties of the feature. */
+  properties?: Maybe<RouteDetailsLegFeatureProperties>;
+};
+
+export type RouteDetailsLegFeatureProperties = {
+  /** 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?: Maybe<Scalars["Int"]>;
+  /** Value of the current weight of the occupants. */
+  total_occupant_weight?: Maybe<Scalars["Float"]>;
+  /** Value of the current weight of the cargo. */
+  total_cargo_weight?: Maybe<Scalars["Float"]>;
+};
+
+export type RouteDetailsLegFeaturePropertiestemperatureArgs = {
+  unit?: Maybe<TemperatureUnit>;
+};
+
+export type RouteDetailsLegFeaturePropertiestotal_occupant_weightArgs = {
+  unit?: Maybe<WeightUnit>;
+};
+
+export type RouteDetailsLegFeaturePropertiestotal_cargo_weightArgs = {
+  unit?: Maybe<WeightUnit>;
+};
+
+export type RouteDetailsLegManeuverPoints = {
+  /** Number of polyline points which are included in this instruction. */
+  size: Scalars["Int"];
+  /** Interval of points that are included in this instruction, an array with 2 values, where the first value is the index of the polyline where the interval starts. The second value is where it ends. */
+  interval: Array<Scalars["Int"]>;
+};
+
+/** Type of a maneuver indicating the main action. */
+export enum RouteDetailsLegManeuverType {
+  UNKNOWN = "UNKNOWN",
+  U_TURN_UNKNOWN = "U_TURN_UNKNOWN",
+  U_TURN_LEFT = "U_TURN_LEFT",
+  KEEP_LEFT = "KEEP_LEFT",
+  LEAVE_ROUNDABOUT = "LEAVE_ROUNDABOUT",
+  TURN_SHARP_LEFT = "TURN_SHARP_LEFT",
+  TURN_LEFT = "TURN_LEFT",
+  TURN_SLIGHT_LEFT = "TURN_SLIGHT_LEFT",
+  CONTINUE_ON_STREET = "CONTINUE_ON_STREET",
+  TURN_SLIGHT_RIGHT = "TURN_SLIGHT_RIGHT",
+  TURN_RIGHT = "TURN_RIGHT",
+  TURN_SHARP_RIGHT = "TURN_SHARP_RIGHT",
+  FINISH = "FINISH",
+  REACHED_VIA = "REACHED_VIA",
+  REACHED_CHARGING_STATION = "REACHED_CHARGING_STATION",
+  USE_ROUNDABOUT = "USE_ROUNDABOUT",
+  KEEP_RIGHT = "KEEP_RIGHT",
+  U_TURN_RIGHT = "U_TURN_RIGHT",
+  PT_START_TRIP = "PT_START_TRIP",
+  PT_TRANSFER = "PT_TRANSFER",
+  PT_END_TRIP = "PT_END_TRIP",
+  IGNORE = "IGNORE"
+}
+
+export type RouteDetailsLegSection = {
+  /** Section type. */
+  type: RouteDetailsLegSectionType;
+  /** Origin point. */
+  origin: RouteDetailsLegSectionFeaturePoint;
+  /** Destination point. */
+  destination: RouteDetailsLegSectionFeaturePoint;
+  /** Aggregation of tags over the current section. */
+  tags: Array<RouteDetailsTag>;
+  /** Polyline containing encoded coordinates. */
+  polyline?: Maybe<Scalars["String"]>;
+  /** Distance from the start to the end of a section. */
+  distance: Scalars["Float"];
+  /** Total drive time from the start to the end of a section, in seconds. */
+  duration: Scalars["Float"];
+  /** Total energy used in a section in kilowatt-hours. */
+  consumption: Scalars["Float"];
+};
+
+export type RouteDetailsLegSectionpolylineArgs = {
+  decimals: PolylineInputDecimals;
+};
+
+export type RouteDetailsLegSectiondistanceArgs = {
+  unit?: Maybe<DistanceUnit>;
+};
+
+export type RouteDetailsLegSectionFeaturePoint = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: Point;
+  /** Properties of the feature. */
+  properties: RouteDetailsLegSectionFeaturePointProperties;
+};
+
+export type RouteDetailsLegSectionFeaturePointProperties = {
+  /** Number of occupants present in the vehicle. */
+  occupants: Scalars["Int"];
+  /** Value of the current weight of the occupants. */
+  total_occupant_weight?: Maybe<Scalars["Float"]>;
+  /** Value of the current weight of the cargo. */
+  total_cargo_weight?: Maybe<Scalars["Float"]>;
 };
 
-export type RouteEndOfLifeFluidsEmissionstotalArgs = {
+export type RouteDetailsLegSectionFeaturePointPropertiestotal_occupant_weightArgs = {
+  unit?: Maybe<WeightUnit>;
+};
+
+export type RouteDetailsLegSectionFeaturePointPropertiestotal_cargo_weightArgs = {
+  unit?: Maybe<WeightUnit>;
+};
+
+/** Type of a route details leg section. */
+export enum RouteDetailsLegSectionType {
+  DRIVING = "driving",
+  FERRY = "ferry",
+  WALKING = "walking"
+}
+
+export type RouteDetailsLegStation = {
+  /** ID of a station. */
+  station_id: Scalars["ID"];
+  /** ID of the EVSE that was selected in a route. */
+  evse_id?: Maybe<Scalars["ID"]>;
+  /** ID of the connector that was selected in a route. */
+  connector_id: Scalars["ID"];
+};
+
+/** Type of a leg. */
+export enum RouteDetailsLegType {
+  STATION = "station",
+  STATION_VIA = "station_via",
+  STATION_FINAL = "station_final",
+  STATION_AMENITY = "station_amenity",
+  VIA = "via",
+  FINAL = "final"
+}
+
+export type RouteDetailsManeuver = {
+  /** Type of instruction. */
+  type: RouteDetailsLegManeuverType;
+  /** Location of the maneuver. */
+  location?: Maybe<RouteDetailsLegFeaturePoint>;
+  /** Name of the street on which an instruction is. */
+  name?: Maybe<Scalars["String"]>;
+  /** Distance, in meters, of a route instruction. */
+  distance: Scalars["Float"];
+  /** Duration, in seconds, of a route instruction. */
+  duration: Scalars["Int"];
+  /** Information about the points on a polyline. */
+  points: RouteDetailsLegManeuverPoints;
+  /** Exit number on a roundabout. This field exists only on sign `USE_ROUNDABOUT` (6), otherwise this value is null. */
+  exit_number?: Maybe<Scalars["Int"]>;
+  /** Curvature angle between the roundabout and the exit of the roundabout. This field exists only on sign USE_ROUNDABOUT (6), otherwise this value is `null`. */
+  turn_angle?: Maybe<Scalars["Float"]>;
+  /** Aggregation of tags over the current maneuver. */
+  tags?: Maybe<Array<RouteDetailsTag>>;
+};
+
+export type RouteDetailsManeuverdistanceArgs = {
+  unit?: Maybe<DistanceUnit>;
+};
+
+export type RouteDetailsPathSegment = {
+  /** Elevation value of a route path segment. */
+  elevation: Scalars["Float"];
+  /** Average speed of a route path segment. */
+  average_speed: Scalars["Float"];
+  /** Consumption, in kilowatt hours, of a route path segment. */
+  consumption: Scalars["Float"];
+  /** Distance of a route path segment. */
+  distance: Scalars["Float"];
+  /** Duration, in seconds, of a route path segment. */
+  duration: Scalars["Float"];
+  /** State of charge, in kilowatt hours, of a route path segment. */
+  state_of_charge?: Maybe<Scalars["Float"]>;
+  /** Maximum vehicle speed of a route path segment. */
+  max_speed: Scalars["Float"];
+};
+
+export type RouteDetailsPathSegmentelevationArgs = {
+  unit?: Maybe<DistanceUnit>;
+};
+
+export type RouteDetailsPathSegmentaverage_speedArgs = {
+  unit?: Maybe<SpeedUnit>;
+};
+
+export type RouteDetailsPathSegmentdistanceArgs = {
+  unit?: Maybe<DistanceUnit>;
+};
+
+export type RouteDetailsPathSegmentstate_of_chargeArgs = {
+  unit?: Maybe<StateOfChargeUnit>;
+};
+
+export type RouteDetailsPathSegmentmax_speedArgs = {
+  unit?: Maybe<SpeedUnit>;
+};
+
+/** Money saving information. */
+export type RouteDetailsSavings = {
+  /** Money saved by a user driving this route with an electric vehicle. */
+  money?: Maybe<Scalars["Float"]>;
+  /** Average gas price with which the calculation was made. */
+  average_gas_price?: Maybe<Scalars["Float"]>;
+  /** Average energy price with which the calculation was made. */
+  average_energy_price?: Maybe<Scalars["Float"]>;
+};
+
+/** Tags of a route. */
+export enum RouteDetailsTag {
+  ROAD = "road",
+  HIGHWAY = "highway",
+  TOLL = "toll",
+  FERRY = "ferry",
+  WALKING = "walking",
+  CROSSBORDER = "crossborder"
+}
+
+export type RouteEmbeddedEmissions = {
+  /** Total embedded emissions. */
+  total: Scalars["Float"];
+  /** Manufacturing emissions. */
+  manufacturing: RouteEmbeddedManufacturingEmissions;
+  /** Total distribution emissions. */
+  distribution: Scalars["Float"];
+  /** Distribution sea segment emissions. */
+  maritime: RouteEmbeddedMaritimeEmissions;
+  /** Distribution land segment emissions. */
+  land: RouteEmbeddedLandEmissions;
+};
+
+export type RouteEmbeddedEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteEndOfLifeFluidsEmissionswiperArgs = {
+export type RouteEmbeddedEmissionsdistributionArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteEndOfLifeFluidsEmissionsbrakeArgs = {
+export type RouteEmbeddedLandEmissions = {
+  /** Total embedded land segment emissions. */
+  total: Scalars["Float"];
+  /** Distribution land segment emissions from fuel consumption. */
+  fuel: Scalars["Float"];
+  /** Distribution land segment lifecycle emissions. */
+  lifecycle: Scalars["Float"];
+};
+
+export type RouteEmbeddedLandEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteEndOfLifeFluidsEmissionscoolantArgs = {
+export type RouteEmbeddedLandEmissionsfuelArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteEndOfLifeFluidsEmissionstransmissionArgs = {
+export type RouteEmbeddedLandEmissionslifecycleArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteEndOfLifeFluidsEmissionsmotor_oilArgs = {
+export type RouteEmbeddedManufacturingEmissions = {
+  /** Total embedded manufacturing emissions. */
+  total: Scalars["Float"];
+  /** Vehicle body manufacturing emissions. */
+  body: Scalars["Float"];
+  /** Lithium ion battery manufacturing emissions. */
+  battery?: Maybe<Scalars["Float"]>;
+};
+
+export type RouteEmbeddedManufacturingEmissionstotalArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmbeddedManufacturingEmissionsbodyArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmbeddedManufacturingEmissionsbatteryArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmbeddedMaritimeEmissions = {
+  /** Total embedded maritime emissions. */
+  total: Scalars["Float"];
+  /** Fuel related maritime segment emissions. */
+  fuel: Scalars["Float"];
+  /** Port facility related maritime segment emissions. */
+  port: Scalars["Float"];
+  /** Idling related maritime segment emissions. */
+  idle: Scalars["Float"];
+  /** Distributed lifecycle related maritime segment emissions. */
+  lifecycle: Scalars["Float"];
+};
+
+export type RouteEmbeddedMaritimeEmissionstotalArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmbeddedMaritimeEmissionsfuelArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmbeddedMaritimeEmissionsportArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmbeddedMaritimeEmissionsidleArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmbeddedMaritimeEmissionslifecycleArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEmissions = {
+  /** ID of the route for which we retrieve the emissions profile. */
+  route_id: Scalars["ID"];
+  /** ID of the route alternative for which we retrieve the emissions profile. */
+  route_alternative_id: Scalars["ID"];
+  /** Emissions profile for the vehicle used in route. */
+  route_vehicle: RouteVehicleEmissions;
+  /** Emissions profile for an equivalent internal combustion engine vehicle. */
+  internal_combustion_vehicle: RouteInternalCombustionVehicleEmissions;
+};
+
+export type RouteEmissionsinternal_combustion_vehicleArgs = {
+  fuel_type?: Maybe<RouteOperationalFuelType>;
+};
+
+export type RouteEndOfLifeEmissions = {
+  /** Total end of life emissions. */
+  total: Scalars["Float"];
+  /** Fluid related end of life emissions. */
+  fluids: FluidEndOfLifeEmissions;
+  /** Battery related end of life emissions. */
+  battery: Scalars["Float"];
+  /** Tire related end of life emissions. */
+  tires: Scalars["Float"];
+  /** Body end of life emissions. */
+  body: Scalars["Float"];
+  /** Transport end of life emissions. */
+  transport: Scalars["Float"];
+};
+
+export type RouteEndOfLifeEmissionstotalArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEndOfLifeEmissionsbatteryArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEndOfLifeEmissionstiresArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEndOfLifeEmissionsbodyArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteEndOfLifeEmissionstransportArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
@@ -4587,13 +5512,15 @@ export enum RouteInstructionSign {
 export type RouteInternalCombustionVehicleEmissions = {
   /** Total co2e emissions. */
   total: Scalars["Float"];
-  /** Embedded emissions. */
+  /** Total co2e emissions from vehicle operational processes calculated using the methodology in section 5.2.2 of ISO 14083:2023 and default emissions intensities in Annex K of the same document. */
+  iso_14083_2023: Scalars["Float"];
+  /** Embedded emissions, for example emissions produced during manufacturing, transportation, and delivery. */
   embedded: RouteEmbeddedEmissions;
   /** Operational emissions. */
   operational: RouteInternalCombustionVehicleOperationalEmissions;
   /** End of life emissions. */
   end_of_life: RouteEndOfLifeEmissions;
-  /** Emissions info for the legs in the order as within the route. */
+  /** Emissions info for the legs in the same order as in the route. */
   legs: Array<RouteInternalCombustionVehicleLegEmissions>;
 };
 
@@ -4601,14 +5528,20 @@ export type RouteInternalCombustionVehicleEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
+export type RouteInternalCombustionVehicleEmissionsiso_14083_2023Args = {
+  unit?: Maybe<EmissionUnit>;
+};
+
 export type RouteInternalCombustionVehicleLegEmissions = {
-  /** Total co2e emissions for the leg. */
+  /** Total co2e emissions. */
   total: Scalars["Float"];
-  /** Embedded emissions for the leg. */
+  /** Total co2e emissions from vehicle operational processes calculated using the methodology in section 5.2.2 of ISO 14083:2023 and default emissions intensities in Annex K of the same document. */
+  iso_14083_2023: Scalars["Float"];
+  /** Embedded emissions, for example emissions produced during manufacturing, transportation, and delivery. */
   embedded: RouteEmbeddedEmissions;
-  /** Operational emissions for the leg. */
+  /** Operational emissions. */
   operational: RouteInternalCombustionVehicleOperationalEmissions;
-  /** End of life emissions for the leg. */
+  /** End of life emissions. */
   end_of_life: RouteEndOfLifeEmissions;
 };
 
@@ -4616,14 +5549,18 @@ export type RouteInternalCombustionVehicleLegEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
+export type RouteInternalCombustionVehicleLegEmissionsiso_14083_2023Args = {
+  unit?: Maybe<EmissionUnit>;
+};
+
 export type RouteInternalCombustionVehicleOperationalEmissions = {
   /** Total operational emissions. */
   total: Scalars["Float"];
-  /** Fuel emissions data. */
+  /** Fuel emissions. */
   fuel: RouteOperationalFuelEmissions;
-  /** Total road infrastructure emissions. */
+  /** Road infrastructure emissions. */
   infrastructure: RouteOperationalInfrastructureEmissions;
-  /** Total maintenance emissions. */
+  /** Maintenance emissions. */
   maintenance: RouteOperationalMaintenanceEmissions;
 };
 
@@ -4705,6 +5642,75 @@ export type RouteLegMeta = {
   warnings: Array<RouteMetaWarning>;
 };
 
+export type RouteLegOperationalElectricityEmissions = {
+  /** Total electricity emissions. */
+  total: Scalars["Float"];
+  /** Base emissions without efficiency losses. */
+  base_value: Scalars["Float"];
+  /** Emissions for electricity lost in the battery. */
+  battery_losses: Scalars["Float"];
+  /** Emissions for electricity lost in transmission. */
+  transmission_losses: Scalars["Float"];
+  /** Emissions for electricity lost during charging. */
+  chargepoint_losses: Scalars["Float"];
+  /** Electricity efficiency information. */
+  efficiency: RouteOperationalElectricityEmissionsEfficiency;
+  /** Electricity intensity information. */
+  intensity: RouteLegOperationalElectricityEmissionsIntensity;
+};
+
+export type RouteLegOperationalElectricityEmissionstotalArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteLegOperationalElectricityEmissionsbase_valueArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteLegOperationalElectricityEmissionsbattery_lossesArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteLegOperationalElectricityEmissionstransmission_lossesArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteLegOperationalElectricityEmissionschargepoint_lossesArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+/** Electricity emission intensity for a leg */
+export type RouteLegOperationalElectricityEmissionsIntensity = {
+  /** Total average electricity emissions intensity in unit CO2e/kWh. */
+  total: Scalars["Float"];
+  /** Base regional electricity emissions intensity for the leg. */
+  base_regional_value: EmissionsFactor;
+  /** Base regional electricity intensity used for the ISO 14083:2023 emissions estimation. */
+  base_iso_14083_2023_regional_value: EmissionsFactor;
+  /** Electricity mix for the leg. */
+  energy_sources: RouteOperationalElectricityEnergySources;
+  /** Average emissions intensity of processing and transport of primary energy, power generation infrastructure, etc. in unit CO2e/kWh. */
+  infrastructure: Scalars["Float"];
+  /** Estimated electricity demand at the time and place the electricity for this leg was obtained as a fraction of the annual average demand. */
+  average_demand: Scalars["Float"];
+  /** Fraction of regional power generation that is not affected by demand (is assumed to always be on). */
+  base_load_fraction: Scalars["Float"];
+  /** Season for which the leg was calculated. */
+  season: RouteOperationalElectricitySeason;
+  /** Climate for which the leg was calculated. */
+  climate: RouteOperationalElectricityClimate;
+};
+
+/** Electricity emission intensity for a leg */
+export type RouteLegOperationalElectricityEmissionsIntensitytotalArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+/** Electricity emission intensity for a leg */
+export type RouteLegOperationalElectricityEmissionsIntensityinfrastructureArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
 export type RouteMeta = {
   /** Warnings that certain conditions specified in a route mutation are not respected. */
   warnings: Array<RouteMetaWarning>;
@@ -4719,6 +5725,17 @@ export type RouteMetaWarning = {
   data?: Maybe<Scalars["JSON"]>;
 };
 
+export type RouteMetadata = {
+  /** Refers to the x-app-id specified in the headers. */
+  app_id: Scalars["ID"];
+  /** Date when a route was created by a createRoute mutation. */
+  created_at: Scalars["DateTime"];
+  /** Last updated date of a route. */
+  updated_at: Scalars["DateTime"];
+  /** Length of time required to successfully calculate a route, in milliseconds. */
+  computation_time?: Maybe<Scalars["Int"]>;
+};
+
 /** Köppen climate classification. */
 export enum RouteOperationalElectricityClimate {
   /** Tropical rain forest climate. */
@@ -4789,7 +5806,7 @@ export type RouteOperationalElectricityEmissions = {
   /** Total electricity emissions. */
   total: Scalars["Float"];
   /** Base emissions without efficiency losses. */
-  base_emissions: Scalars["Float"];
+  base_value: Scalars["Float"];
   /** Emissions for electricity lost in the battery. */
   battery_losses: Scalars["Float"];
   /** Emissions for electricity lost in transmission. */
@@ -4797,16 +5814,16 @@ export type RouteOperationalElectricityEmissions = {
   /** Emissions for electricity lost during charging. */
   chargepoint_losses: Scalars["Float"];
   /** Electricity efficiency information. */
-  electricity_efficiency: RouteOperationalElectricityEmissionsEfficiency;
+  efficiency: RouteOperationalElectricityEmissionsEfficiency;
   /** Electricity intensity information. */
-  electricity_intensity: RouteOperationalElectricityEmissionsIntensity;
+  intensity: RouteOperationalElectricityEmissionsIntensity;
 };
 
 export type RouteOperationalElectricityEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalElectricityEmissionsbase_emissionsArgs = {
+export type RouteOperationalElectricityEmissionsbase_valueArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
@@ -4824,27 +5841,27 @@ export type RouteOperationalElectricityEmissionschargepoint_lossesArgs = {
 
 export type RouteOperationalElectricityEmissionsEfficiency = {
   /** Average total electricity efficiency. */
-  total_efficiency: Scalars["Float"];
+  total: Scalars["Float"];
   /** Average efficiency of the battery. */
-  battery_efficiency: Scalars["Float"];
-  /** Average efficiency of electricity transmission. */
-  transmission_efficiency: Scalars["Float"];
-  /** Average base regional grid efficiency. */
-  base_transmission_efficiency: Scalars["Float"];
+  battery: Scalars["Float"];
+  /** Average estimated transmission efficiency using the base transmission efficiency adjusting for temperature. */
+  transmission: Scalars["Float"];
+  /** Average base regional grid transmission efficiency. */
+  base_transmission: Scalars["Float"];
   /** Average transmission efficiency change due to temperature. */
-  transmission_efficiency_temperature_modifier: Scalars["Float"];
+  transmission_temperature_modifier: Scalars["Float"];
   /** Average efficiency of the chargepoint. */
-  chargepoint_efficiency: Scalars["Float"];
-  /** Average evse efficiency. */
-  evse_efficiency: Scalars["Float"];
-  /** Average breaker efficiency. */
-  breaker_efficiency: Scalars["Float"];
-  /** Average power electronics unit efficiency. */
-  power_electronics_unit_efficiency: Scalars["Float"];
-  /** Average transformer efficiency. */
-  transformer_efficiency: Scalars["Float"];
+  chargepoint: Scalars["Float"];
+  /** Average evse (electric vehicle supply equipment) efficiency of the chargepoint. */
+  evse: Scalars["Float"];
+  /** Average circuit breaker efficiency of the chargepoint. */
+  breaker: Scalars["Float"];
+  /** Average power electronics unit efficiency of the chargepoint. */
+  power_electronics_unit: Scalars["Float"];
+  /** Average transformer efficiency of the chargepoint. */
+  transformer: Scalars["Float"];
   /** Change in chargepoint efficiency due to temperature. */
-  chargepoint_efficiency_temperature_modifier: Scalars["Float"];
+  chargepoint_temperature_modifier: Scalars["Float"];
   /** Average charging current in amperes. */
   average_charging_current: Scalars["Float"];
   /** Average charging voltage in volts. */
@@ -4863,58 +5880,67 @@ export type RouteOperationalElectricityEmissionsEfficiencyaverage_regional_tempe
   unit?: Maybe<TemperatureUnit>;
 };
 
-export type RouteOperationalElectricityEmissionsGenerationMethods = {
-  /** Fraction of coal production. */
-  coal: Scalars["Float"];
-  /** Fraction of gas production. */
-  gas: Scalars["Float"];
-  /** Fraction of hydroelectric production. */
-  hydro: Scalars["Float"];
-  /** Fraction of solar production. */
-  solar: Scalars["Float"];
-  /** Fraction of wind production. */
-  wind: Scalars["Float"];
-  /** Fraction of oil production. */
-  oil: Scalars["Float"];
-  /** Fraction of nuclear production. */
-  nuclear: Scalars["Float"];
-  /** Fraction of biofuel production. */
-  biofuel: Scalars["Float"];
-  /** Fraction of other production. */
-  other: Scalars["Float"];
-};
-
+/** Electricity emission intensity for the route */
 export type RouteOperationalElectricityEmissionsIntensity = {
-  /** Average route electricity emissions intensity in unit CO2e/kWh. */
-  total_electricity_intensity: Scalars["Float"];
-  /** Base regional electricity emissions intensity in unit CO2e/kWh. */
-  base_electricity_intensity: Scalars["Float"];
-  /** Generation methods of electricity production. */
-  generation_methods: RouteOperationalElectricityEmissionsGenerationMethods;
-  /** Average emissions intensity of processing and transport of primary energy, power generation infrastructure, etc in unit CO2e/kWh. */
-  electricity_infrastructure_intensity: Scalars["Float"];
-  /** Season for which the route was calculated. */
-  season: RouteOperationalElectricitySeason;
-  /** The climate for which the route was calculated. */
-  climate: RouteOperationalElectricityClimate;
-  /** Average electricity demand at the time of route charges as a fraction of average demand. */
-  average_electricity_demand: Scalars["Float"];
-  /** Fraction of regional power generation that is not affected by demand (always on). */
+  /** Total average electricity emissions intensity in unit CO2e/kWh. */
+  total: Scalars["Float"];
+  /** Average base regional electricity emissions intensity in unit CO2e/kWh. */
+  average_base_regional_value: Scalars["Float"];
+  /** Total electricity intensity used for iso 14083:2023 scope emissions estimate in unit CO2e/kWh. */
+  iso_14083_2023: Scalars["Float"];
+  /** Average electricity mix for the route. */
+  energy_sources: RouteOperationalElectricityEnergySources;
+  /** Average emissions intensity of processing and transport of primary energy, power generation infrastructure, etc. in unit CO2e/kWh. */
+  infrastructure: Scalars["Float"];
+  /** Average electricity demand at the time of route charges as a fraction of the annual average demand. */
+  average_demand: Scalars["Float"];
+  /** Fraction of regional power generation that is not affected by demand (is assumed to always be on). */
   base_load_fraction: Scalars["Float"];
 };
 
-export type RouteOperationalElectricityEmissionsIntensitytotal_electricity_intensityArgs = {
+/** Electricity emission intensity for the route */
+export type RouteOperationalElectricityEmissionsIntensitytotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalElectricityEmissionsIntensitybase_electricity_intensityArgs = {
+/** Electricity emission intensity for the route */
+export type RouteOperationalElectricityEmissionsIntensityaverage_base_regional_valueArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalElectricityEmissionsIntensityelectricity_infrastructure_intensityArgs = {
+/** Electricity emission intensity for the route */
+export type RouteOperationalElectricityEmissionsIntensityiso_14083_2023Args = {
   unit?: Maybe<EmissionUnit>;
 };
 
+/** Electricity emission intensity for the route */
+export type RouteOperationalElectricityEmissionsIntensityinfrastructureArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteOperationalElectricityEnergySources = {
+  /** Electricity produced by coal power plants. */
+  coal: ElectricityGenerationMethod;
+  /** Electricity produced by natural gas power plants. */
+  gas: ElectricityGenerationMethod;
+  /** Electricity produced by hydroelectric power. */
+  hydro: ElectricityGenerationMethod;
+  /** Electricity produced by solar power. */
+  solar: ElectricityGenerationMethod;
+  /** Electricity produced by wind power. */
+  wind: ElectricityGenerationMethod;
+  /** Electricity produced by oil power plants. */
+  oil: ElectricityGenerationMethod;
+  /** Electricity produced by nuclear power plants. */
+  nuclear: ElectricityGenerationMethod;
+  /** Electricity produced by biofuel/biomass. */
+  biofuel: ElectricityGenerationMethod;
+  /** Electricity produced by geothermal power plants. */
+  geothermal: ElectricityGenerationMethod;
+  /** Electricity produced by other means. */
+  other: ElectricityGenerationMethod;
+};
+
 /** Yearly seasons. */
 export enum RouteOperationalElectricitySeason {
   /** Winter season. */
@@ -4927,56 +5953,17 @@ export enum RouteOperationalElectricitySeason {
   FALL = "fall"
 }
 
-export type RouteOperationalFluidEmissions = {
-  /** Total fluid. */
-  total: Scalars["Float"];
-  /** Total wiper fluid maintenance emissions. */
-  wiper: Scalars["Float"];
-  /** Total brake fluid maintenance emissions. */
-  brake: Scalars["Float"];
-  /** Total powertrain coolant fluid maintenance emissions. */
-  coolant: Scalars["Float"];
-  /** Total transmission fluid maintenance emissions. */
-  transmission: Scalars["Float"];
-  /** Total motor oil maintenance emissions. */
-  motor_oil?: Maybe<Scalars["Float"]>;
-};
-
-export type RouteOperationalFluidEmissionstotalArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
-export type RouteOperationalFluidEmissionswiperArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
-export type RouteOperationalFluidEmissionsbrakeArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
-export type RouteOperationalFluidEmissionscoolantArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
-export type RouteOperationalFluidEmissionstransmissionArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
-export type RouteOperationalFluidEmissionsmotor_oilArgs = {
-  unit?: Maybe<EmissionUnit>;
-};
-
 export type RouteOperationalFuelEmissions = {
-  /** Total fuel for the route. */
+  /** Total fuel emissions for the route. */
   total: Scalars["Float"];
-  /** Direct (tank to wheels) emissions of the fuel. */
-  direct_emissions: Scalars["Float"];
-  /** Indirect (well to tank) emissions of the fuel. */
-  indirect_emissions: Scalars["Float"];
-  /** Fuel consumption for the route in litres. */
-  fuel_consumption: Scalars["Float"];
+  /** Direct (tank to wheels) fuel emissions for the route. */
+  direct: Scalars["Float"];
+  /** Indirect (well to tank) fuel emissions for the route. */
+  indirect: Scalars["Float"];
+  /** Total fuel consumption for the route. */
+  consumption: Scalars["Float"];
   /** Estimated internal combustion vehicle weight. */
-  weight: Scalars["Float"];
+  vehicle_weight: Scalars["Float"];
   /** Estimated internal combustion vehicle engine torque. */
   engine_torque: Scalars["Float"];
   /** Average powertrain efficiency. */
@@ -4993,19 +5980,19 @@ export type RouteOperationalFuelEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalFuelEmissionsdirect_emissionsArgs = {
+export type RouteOperationalFuelEmissionsdirectArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalFuelEmissionsindirect_emissionsArgs = {
+export type RouteOperationalFuelEmissionsindirectArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalFuelEmissionsfuel_consumptionArgs = {
+export type RouteOperationalFuelEmissionsconsumptionArgs = {
   unit?: Maybe<FuelUnit>;
 };
 
-export type RouteOperationalFuelEmissionsweightArgs = {
+export type RouteOperationalFuelEmissionsvehicle_weightArgs = {
   unit?: Maybe<WeightUnit>;
 };
 
@@ -5026,11 +6013,11 @@ export enum RouteOperationalFuelType {
 }
 
 export type RouteOperationalInfrastructureEmissions = {
-  /** Total infrastructure. */
+  /** Total road infrastructure emissions. */
   total: Scalars["Float"];
-  /** Embedded (construction, decommissioning, etc) emissions cost. */
+  /** Embedded (construction, decommissioning, etc) road infrastructure emissions. */
   embedded: Scalars["Float"];
-  /** Induced maintenance emissions. */
+  /** Induced road infrastructure maintenance emissions. */
   maintenance: Scalars["Float"];
 };
 
@@ -5047,38 +6034,86 @@ export type RouteOperationalInfrastructureEmissionsmaintenanceArgs = {
 };
 
 export type RouteOperationalMaintenanceEmissions = {
-  /** Total maintenance. */
-  total: Scalars["Float"];
-  /** Total fluid related maintenance emissions. */
-  fluids: RouteOperationalFluidEmissions;
+  /** Total maintenance emissions. */
+  total: RouteOperationalMaintenanceEmissionsField;
+  /** Fluid related maintenance emissions. */
+  fluids: FluidMaintenanceEmissions;
   /** Battery related maintenance emissions. */
-  battery: Scalars["Float"];
+  battery: RouteOperationalMaintenanceEmissionsField;
   /** Tire related maintenance emissions. */
-  tires: Scalars["Float"];
+  tires: RouteOperationalMaintenanceEmissionsField;
   /** Miscellaneous component maintenance emissions. */
-  components: Scalars["Float"];
+  components: RouteOperationalMaintenanceEmissionsField;
   /** Accident repair related maintenance emissions. */
-  repair: Scalars["Float"];
+  repair: RouteOperationalMaintenanceEmissionsField;
 };
 
-export type RouteOperationalMaintenanceEmissionstotalArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteOperationalMaintenanceEmissionsField = {
+  /** Total emissions. */
+  total: Scalars["Float"];
+  /** Emissions from replacement production and transport. */
+  production: Scalars["Float"];
+  /** Emissions from disposal. */
+  disposal: Scalars["Float"];
 };
 
-export type RouteOperationalMaintenanceEmissionsbatteryArgs = {
+export type RouteOperationalMaintenanceEmissionsFieldtotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalMaintenanceEmissionstiresArgs = {
+export type RouteOperationalMaintenanceEmissionsFieldproductionArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalMaintenanceEmissionscomponentsArgs = {
+export type RouteOperationalMaintenanceEmissionsFielddisposalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
-export type RouteOperationalMaintenanceEmissionsrepairArgs = {
-  unit?: Maybe<EmissionUnit>;
+export type RouteOperatorPreferences = {
+  /** Ranking of an operator with multiple levels, each level having its own penalty value. */
+  ranking?: Maybe<RouteOperatorPreferencesRanking>;
+  /** Route operators that should be excluded. */
+  exclude?: Maybe<Array<RouteOperatorsValue>>;
+};
+
+/** Prioritized operators for a route calculation. */
+export type RouteOperatorPreferencesInput = {
+  /** Ranking of an operator with multiple levels, each level having its own penalty value. */
+  ranking?: Maybe<RouteOperatorPreferencesRankingInput>;
+  /** Route operators that should be excluded. */
+  exclude?: Maybe<Array<RouteOperatorsValueInput>>;
+};
+
+export type RouteOperatorPreferencesRanking = {
+  /** Flag indicating if an operator should be preferred or required. */
+  type: RouteOperatorsType;
+  /** Ranking levels for operator ranking. */
+  levels?: Maybe<RouteOperatorPreferencesRankingLevels>;
+};
+
+export type RouteOperatorPreferencesRankingInput = {
+  /** Flag indicating if the operators ranking should be preferred or required. */
+  type: RouteOperatorsType;
+  /** Ranking levels for operator ranking. */
+  levels?: Maybe<RouteOperatorPreferencesRankingLevelsInput>;
+};
+
+export type RouteOperatorPreferencesRankingLevels = {
+  /** Least significant level for operators ranking. */
+  low?: Maybe<Array<RouteOperatorsValue>>;
+  /** Medium level for operators ranking. */
+  medium?: Maybe<Array<RouteOperatorsValue>>;
+  /** Most significant level for operator ranking. */
+  high?: Maybe<Array<RouteOperatorsValue>>;
+};
+
+export type RouteOperatorPreferencesRankingLevelsInput = {
+  /** Least significant level for operator ranking. */
+  low?: Maybe<Array<RouteOperatorsValueInput>>;
+  /** Medium level for operator ranking. */
+  medium?: Maybe<Array<RouteOperatorsValueInput>>;
+  /** Most significant level three for operator ranking. */
+  high?: Maybe<Array<RouteOperatorsValueInput>>;
 };
 
 /** Prioritized operators for a route calculation. */
@@ -5151,7 +6186,7 @@ export type RouteOperatorsRankingInput = {
 
 /** Type of operator prioritization for a route. */
 export enum RouteOperatorsType {
-  /** Default option. Operators ranking will not be taken into account if no type is given. */
+  /** Operators ranking will not be taken into account if no type is given. */
   NONE = "none",
   /** Operators given in the operators ranking will be preferred when calculating routes. */
   PREFERRED = "preferred",
@@ -5159,6 +6194,56 @@ export enum RouteOperatorsType {
   REQUIRED = "required"
 }
 
+export type RouteOperatorsValue = {
+  /** ID of an operator. */
+  id: Scalars["ID"];
+  /** List of countries in which the operator should be preferred/excluded. When omitted the operator will be preferred/excluded in every country. */
+  countries?: Maybe<Array<CountryCodeAlpha2>>;
+};
+
+export type RouteOperatorsValueInput = {
+  /** ID of an operator. */
+  id: Scalars["ID"];
+  /** List of countries in which the operator should be preferred/excluded. When omitted the operator will be preferred/excluded in every country. */
+  countries?: Maybe<Array<CountryCodeAlpha2>>;
+};
+
+export type RouteOriginFeaturePoint = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: Point;
+  /** Optional object where additional properties can be specified. */
+  properties?: Maybe<RouteOriginProperties>;
+};
+
+export type RouteOriginFeaturePointInput = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: PointInput;
+  /** Optional object where additional properties can be specified. */
+  properties?: Maybe<RouteOriginPropertiesInput>;
+};
+
+export type RouteOriginProperties = {
+  /** Data about the origin location. */
+  location?: Maybe<RoutePropertiesLocation>;
+  /** Vehicle data at the origin location. */
+  vehicle?: Maybe<RoutePropertiesVehicle>;
+};
+
+export type RouteOriginPropertiesInput = {
+  /** Data about the origin location. */
+  location?: Maybe<RoutePropertiesLocationInput>;
+  /** Vehicle data at the origin location. */
+  vehicle?: Maybe<RoutePropertiesVehicleInput>;
+};
+
 export type RoutePath = {
   /** GeoJSON location of a route path segment. */
   location?: Maybe<Point>;
@@ -5180,6 +6265,67 @@ export type RoutePath = {
   stateOfCharge?: Maybe<Scalars["Float"]>;
 };
 
+export type RoutePropertiesLocation = {
+  /** Name that should overwrite the name that is automatically assigned to this location (for example: address or station name). */
+  name?: Maybe<Scalars["String"]>;
+  /** Duration to stay at this point. */
+  stop_duration?: Maybe<Scalars["Int"]>;
+};
+
+export type RoutePropertiesLocationInput = {
+  /** Name that should overwrite the name that is automatically assigned to this location (for example: address or station name). */
+  name?: Maybe<Scalars["String"]>;
+  /** Duration to stay at this point. */
+  stop_duration?: Maybe<Scalars["Int"]>;
+};
+
+export type RoutePropertiesStation = {
+  /** ID of the station. When provided and valid, the coordinates of this station will be used. */
+  station_id?: Maybe<Scalars["ID"]>;
+  /** External ID of the station. When provided and valid, the coordinates of this station will be used. */
+  external_station_id?: Maybe<Scalars["ID"]>;
+};
+
+export type RoutePropertiesStationInput = {
+  /** ID of the station. When provided and valid, the coordinates of this station will be used. */
+  station_id?: Maybe<Scalars["ID"]>;
+  /** External ID of the station. When provided and valid, the coordinates of this station will be used. */
+  external_station_id?: Maybe<Scalars["ID"]>;
+};
+
+export type RoutePropertiesVehicle = {
+  /** Number of occupants present in the vehicle. */
+  occupants?: Maybe<Scalars["Int"]>;
+  /** Combined weight of the occupants. */
+  total_occupant_weight?: Maybe<TotalOccupantWeight>;
+  /** Weight of the cargo. */
+  total_cargo_weight?: Maybe<TotalCargoWeight>;
+};
+
+export type RoutePropertiesVehicleInput = {
+  /** Number of occupants present in the vehicle. */
+  occupants?: Maybe<Scalars["Int"]>;
+  /** Combined weight of the occupants. */
+  total_occupant_weight?: Maybe<TotalOccupantWeightInput>;
+  /** Weight of the cargo. */
+  total_cargo_weight?: Maybe<TotalCargoWeightInput>;
+};
+
+export type RouteResponse = {
+  /** ID of a route calculation. */
+  id: Scalars["ID"];
+  /** Status of a route. */
+  status: RouteStatus;
+  /** Recommended route. */
+  recommended?: Maybe<RouteDetails>;
+  /** Meta data for a route. */
+  meta: RouteMetadata;
+  /** Route request. */
+  request_input: CreateRoute;
+  /** Region of a route calculation. */
+  region: Scalars["String"];
+};
+
 /** Scheduled charge stop along a route. */
 export type RouteScheduledChargeStop = {
   /** List of amenity types. */
@@ -5227,7 +6373,7 @@ export enum RouteStatus {
   PROCESSING = "processing",
   /** We finished computing the route, with a result. Final status. */
   DONE = "done",
-  /** We finished the computing the route, without any result. Final status. */
+  /** We finished computing the route, without any result. Final status. */
   NOT_FOUND = "not_found",
   /** An error occurred while computing the route. Final status. */
   ERROR = "error"
@@ -5262,16 +6408,142 @@ export enum RouteTagType {
   CROSSBORDER = "crossborder"
 }
 
+export type RouteVehicle = {
+  /** ID of the vehicle. */
+  id: Scalars["ID"];
+  /** EV battery specific configuration. */
+  battery?: Maybe<RouteVehicleBattery>;
+  /** Charging configuration. */
+  charging?: Maybe<RouteVehicleCharging>;
+  /** Average tire pressures of all wheels, starting from the front side (right to left) and then to the rear. */
+  tire_pressure?: Maybe<TirePressure>;
+  /** Value of the vehicle's odometer. */
+  odometer?: Maybe<Odometer>;
+  /** Value of the auxiliary power consumption of the vehicle. */
+  auxiliary_consumption?: Maybe<AuxiliaryConsumption>;
+  /** Flag which indicates if climate control is on. */
+  climate?: Maybe<Scalars["Boolean"]>;
+  /** Vehicle Heat Pump configuration. */
+  heat_pump: HeatPumpMode;
+  /** Vehicle cabin configuration. */
+  cabin: RouteVehicleCabin;
+  /** Revolutions per minute of the motor, a measure of the rotational speed of the motor's rotor component. */
+  motor_rpm?: Maybe<Scalars["Int"]>;
+  /** Value of the outside temperature. */
+  outside_temperature?: Maybe<Temperature>;
+  /** Vehicle is in park, neutral or turned off. */
+  is_parked?: Maybe<Scalars["Boolean"]>;
+  /** Value of the vehicle's speed. */
+  vehicle_speed?: Maybe<VehicleSpeed>;
+  /** Current heading in degrees. */
+  heading?: Maybe<Scalars["Float"]>;
+};
+
+export type RouteVehicleBattery = {
+  /** Battery capacity. */
+  capacity: StateOfCharge;
+  /** State of charge. */
+  state_of_charge: StateOfCharge;
+  /** Minimum final battery state of charge. */
+  final_state_of_charge: StateOfCharge;
+  /** Temperature of the battery. */
+  temperature?: Maybe<Temperature>;
+  /** Battery current in ampere. */
+  current?: Maybe<Scalars["Float"]>;
+  /** Battery voltage in volts. */
+  voltage?: Maybe<Scalars["Float"]>;
+  /** Value of the positive or negative power. When negative, the vehicle is charging. */
+  power?: Maybe<Scalars["Float"]>;
+  /** Indicates if the vehicle is charging. */
+  is_charging?: Maybe<Scalars["Boolean"]>;
+};
+
+/** EV battery specific configuration for a create route mutation. */
+export type RouteVehicleBatteryInput = {
+  /** Battery capacity. */
+  capacity?: Maybe<StateOfChargeInput>;
+  /** Battery state of charge. */
+  state_of_charge?: Maybe<StateOfChargeInput>;
+  /** Minimum battery state of charge. */
+  final_state_of_charge?: Maybe<StateOfChargeInput>;
+  /** Battery temperature. */
+  temperature?: Maybe<TemperatureInput>;
+  /** Battery current in ampere. */
+  current?: Maybe<Scalars["Float"]>;
+  /** Battery voltage in volts. */
+  voltage?: Maybe<Scalars["Float"]>;
+  /** Vehicle power. */
+  power?: Maybe<Scalars["Float"]>;
+  /** Vehicle is currently charging. */
+  is_charging?: Maybe<Scalars["Boolean"]>;
+};
+
+export type RouteVehicleCabin = {
+  /** Flag which indicates if the vehicle cabin was preconditioned for the desired temperature. */
+  is_preconditioned: Scalars["Boolean"];
+  /** Desired cabin temperature. Default is 20 degrees Celsius or 68 degrees Fahrenheit. */
+  desired_temperature: Temperature;
+};
+
+export type RouteVehicleCabinInput = {
+  /** Flag which indicates if the vehicle cabin was preconditioned for the desired temperature. */
+  is_preconditioned?: Scalars["Boolean"];
+  /** Desired cabin temperature. Default is 20 degrees Celsius or 68 degrees Fahrenheit. */
+  desired_temperature: TemperatureInput;
+};
+
+export type RouteVehicleCharging = {
+  /** Mode that indicates if the charging time is optimized or if always charged to the maximum capacity. */
+  mode: ChargeMode;
+  /** Minimum desired power of chargers. */
+  minimum_power: Scalars["Int"];
+  /** Percentage for the minimum limit of the battery's capacity before a recharge. The value should be between 0 and 60. Defaults to 10. */
+  risk_margin: Scalars["Int"];
+  /** Supported connectors. */
+  connectors?: Maybe<Array<RouteVehicleChargingConnector>>;
+  /** Supported adapters. */
+  adapters?: Maybe<Array<RouteVehicleChargingConnector>>;
+};
+
+export type RouteVehicleChargingConnector = {
+  /** Type of the plug. */
+  standard: ConnectorType;
+  /** Maximum charging speed for the plug. */
+  max_charge_speed: ChargeSpeed;
+};
+
+export type RouteVehicleChargingConnectorInput = {
+  /** Plug type. */
+  standard: ConnectorType;
+  /** Maximum charging speed for this plug. */
+  max_charge_speed: ChargeSpeedInput;
+};
+
+export type RouteVehicleChargingInput = {
+  /** Mode that indicates if the charging time is optimized or if always charged to the maximum capacity. */
+  mode?: Maybe<ChargeMode>;
+  /** Minimum desired power of chargers. */
+  minimum_power?: Maybe<Scalars["Float"]>;
+  /** Percentage representing the minimum value of the state of charge at a next charge stop. The value should be between 0 and 60. */
+  risk_margin?: Maybe<Scalars["Int"]>;
+  /** Supported connectors. */
+  connectors?: Maybe<Array<RouteVehicleChargingConnectorInput>>;
+  /** Supported adapters. */
+  adapters?: Maybe<Array<RouteVehicleChargingConnectorInput>>;
+};
+
 export type RouteVehicleEmissions = {
   /** Total co2e emissions. */
   total: Scalars["Float"];
-  /** Embedded emissions. */
+  /** Total co2e emissions from vehicle operational processes calculated using the methodology in section 5.2.2 of ISO 14083:2023 and default emissions intensities in Annex K of the same document. */
+  iso_14083_2023: Scalars["Float"];
+  /** Embedded emissions, for example emissions produced during manufacturing, transportation, and delivery. */
   embedded: RouteEmbeddedEmissions;
   /** Operational emissions. */
   operational: RouteVehicleOperationalEmissions;
   /** End of life emissions. */
   end_of_life: RouteEndOfLifeEmissions;
-  /** Emissions info for the legs in the order as within the route. */
+  /** Emissions info for the legs in the same order as in the route. */
   legs: Array<RouteVehicleLegEmissions>;
 };
 
@@ -5279,13 +6551,51 @@ export type RouteVehicleEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
+export type RouteVehicleEmissionsiso_14083_2023Args = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+/** Vehicle specific input for a create route mutation. */
+export type RouteVehicleInput = {
+  /** ID of the vehicle. */
+  id: Scalars["ID"];
+  /** EV battery specific configuration. */
+  battery?: Maybe<RouteVehicleBatteryInput>;
+  /** Charging configuration. */
+  charging?: Maybe<RouteVehicleChargingInput>;
+  /** Average tire pressures of all wheels. */
+  tire_pressure?: Maybe<TirePressureInput>;
+  /** Odometer (mileage) reading. */
+  odometer?: Maybe<OdometerInput>;
+  /** Average auxiliary power consumption. */
+  auxiliary_consumption?: Maybe<AuxiliaryConsumptionInput>;
+  /** Flag which indicates if climate control is on. */
+  climate?: Maybe<Scalars["Boolean"]>;
+  /** Vehicle Heat Pump configuration. */
+  heat_pump?: Maybe<HeatPumpMode>;
+  /** Vehicle cabin configuration for creating the route. */
+  cabin?: Maybe<RouteVehicleCabinInput>;
+  /** Revolutions per minute of the motor, a measure of the rotational speed of the motor's rotor component. */
+  motor_rpm?: Maybe<Scalars["Int"]>;
+  /** Outside temperature. */
+  outside_temperature?: Maybe<TemperatureInput>;
+  /** Vehicle is in park, neutral or turned off. */
+  is_parked?: Maybe<Scalars["Boolean"]>;
+  /** Vehicle speed. */
+  vehicle_speed?: Maybe<VehicleSpeedInput>;
+  /** Current heading in degrees. */
+  heading?: Maybe<Scalars["Float"]>;
+};
+
 export type RouteVehicleLegEmissions = {
   /** Total co2e emissions for the leg. */
   total: Scalars["Float"];
-  /** Embedded emissions for the leg. */
+  /** Total leg co2e emissions from vehicle operational processes using the methodology in section 5.2.2 of ISO 14083:2023 and default emissions intensities in Annex K of the same document. */
+  iso_14083_2023: Scalars["Float"];
+  /** Embedded emissions, for example emissions produced during manufacturing, transportation, and delivery. */
   embedded: RouteEmbeddedEmissions;
   /** Operational emissions for the leg. */
-  operational: RouteVehicleOperationalEmissions;
+  operational: RouteVehicleLegOperationalEmissions;
   /** End of life emissions for the leg. */
   end_of_life: RouteEndOfLifeEmissions;
 };
@@ -5294,14 +6604,33 @@ export type RouteVehicleLegEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
+export type RouteVehicleLegEmissionsiso_14083_2023Args = {
+  unit?: Maybe<EmissionUnit>;
+};
+
+export type RouteVehicleLegOperationalEmissions = {
+  /** Total operational emissions for the leg. */
+  total: Scalars["Float"];
+  /** Electricity emissions data for the leg. */
+  electricity: RouteLegOperationalElectricityEmissions;
+  /** Total road infrastructure emissions for the leg. */
+  infrastructure: RouteOperationalInfrastructureEmissions;
+  /** Total maintenance emissions for the leg. */
+  maintenance: RouteOperationalMaintenanceEmissions;
+};
+
+export type RouteVehicleLegOperationalEmissionstotalArgs = {
+  unit?: Maybe<EmissionUnit>;
+};
+
 export type RouteVehicleOperationalEmissions = {
   /** Total operational emissions. */
   total: Scalars["Float"];
-  /** Electricity emissions data. */
+  /** Electricity emissions. */
   electricity: RouteOperationalElectricityEmissions;
-  /** Total road infrastructure emissions. */
+  /** Road infrastructure emissions. */
   infrastructure: RouteOperationalInfrastructureEmissions;
-  /** Total maintenance emissions. */
+  /** Maintenance emissions. */
   maintenance: RouteOperationalMaintenanceEmissions;
 };
 
@@ -5309,17 +6638,57 @@ export type RouteVehicleOperationalEmissionstotalArgs = {
   unit?: Maybe<EmissionUnit>;
 };
 
+export type RouteViaFeaturePoint = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: Point;
+  /** Optional object where additional properties can be specified. */
+  properties?: Maybe<RouteViaProperties>;
+};
+
+export type RouteViaFeaturePointInput = {
+  /** ID of the feature. */
+  id?: Maybe<Scalars["ID"]>;
+  /** Feature type. */
+  type: FeatureType;
+  /** Geometry of the feature. */
+  geometry: PointInput;
+  /** Optional object where additional properties can be specified. */
+  properties?: Maybe<RouteViaPropertiesInput>;
+};
+
+export type RouteViaProperties = {
+  /** Location data of the via point. */
+  location?: Maybe<RoutePropertiesLocation>;
+  /** Vehicle data of the via point. */
+  vehicle?: Maybe<RoutePropertiesVehicle>;
+  /** Station data of the via point. */
+  station?: Maybe<RoutePropertiesStation>;
+};
+
+export type RouteViaPropertiesInput = {
+  /** Location data of the via point. */
+  location?: Maybe<RoutePropertiesLocationInput>;
+  /** Vehicle data of the via point. */
+  vehicle?: Maybe<RoutePropertiesVehicleInput>;
+  /** Station data of the via point. */
+  station?: Maybe<RoutePropertiesStationInput>;
+};
+
 /** Scheduled charge stop along a route. */
 export type ScheduledChargeStopInput = {
   /** List of amenity types. */
   types: Array<AmenityType>;
   /** Duration at the amenity, in seconds. The value should be between 900 and 86400. */
   duration: Scalars["Int"];
-  /** Maximum allowed offset from the stop_after value in seconds. Default is 1800. */
+  /** Maximum allowed offset from the stop_after value in seconds. */
   offset?: Maybe<Scalars["Int"]>;
   /** Desired drive time for a scheduled stop after leaving the origin point, in seconds. */
   stop_after: Scalars["Int"];
-  /** Maximum distance from a station to an amenity, in meters. The value should be between 0 and 1000. Default is 1000. */
+  /** Maximum distance from a station to an amenity, in meters. The value should be between 0 and 1000. */
   max_distance_from_station?: Maybe<Scalars["Int"]>;
 };
 
@@ -5328,6 +6697,7 @@ export enum SortDirection {
   DESCENDING = "descending"
 }
 
+/** Speed units. */
 export enum SpeedUnit {
   /** Return the speed in kilometers per hour. */
   KILOMETERS_PER_HOUR = "kilometers_per_hour",
@@ -5343,15 +6713,25 @@ export type StandardStats = {
   total?: Maybe<Scalars["Int"]>;
 };
 
+export type StateOfCharge = {
+  /** Value of the state of charge of the vehicle. */
+  value: Scalars["Float"];
+  /** Type of the state of charge of the vehicle. */
+  type: StateOfChargeUnit;
+  /** Source of inputted data. */
+  source: TelemetryInputSource;
+};
+
 export type StateOfChargeInput = {
   /** Value of the state of charge of the vehicle. */
   value: Scalars["Float"];
   /** Type of the state of charge of the vehicle. */
   type: StateOfChargeUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
 };
 
+/** State of charge unit. */
 export enum StateOfChargeUnit {
   /** Return the state of charge in kilometers. */
   KILOMETER = "kilometer",
@@ -5441,7 +6821,10 @@ export type Station = {
   location_category?: Maybe<Scalars["String"]>;
   /** Coordinates for the location's entrances in decimal degrees. If available, there can be more than one entrances to the location. */
   entrance_for_navigation?: Maybe<Array<OCPIAdditionalGeoLocation>>;
-  /** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer. */
+  /**
+   * Optional object where you can store custom data you need in your application. This extends the current functionalities we offer.
+   * @deprecated No longer used.
+   */
   properties?: Maybe<Scalars["JSON"]>;
   /** A flag that indicates if a station has real-time information about the availability of its connectors. */
   realtime?: Maybe<Scalars["Boolean"]>;
@@ -5522,7 +6905,7 @@ export type StationAroundFilter = {
   location?: Maybe<PointInput>;
   /** Distance, in meters, to search around. */
   distance?: Maybe<Scalars["Int"]>;
-  /** Powers in kWh. */
+  /** Powers in kW. */
   powers?: Maybe<Array<Maybe<Scalars["Float"]>>>;
   /** Amenities available near a station. */
   amenities?: Maybe<Array<Maybe<Amenities>>>;
@@ -5542,7 +6925,7 @@ export type StationAroundQuery = {
   location?: Maybe<PointInput>;
   /** Distance, in meters, to search around. */
   distance?: Maybe<Scalars["Int"]>;
-  /** Power in kWh. */
+  /** Power in kW. */
   power?: Maybe<Array<Maybe<Scalars["Float"]>>>;
   /** Amenities available near a station. Values: restaurant, bathroom, supermarket, playground, coffee, shopping, museum, hotel, park. */
   amenities?: Maybe<Array<Maybe<Scalars["String"]>>>;
@@ -5642,7 +7025,7 @@ export type StationHeavyVehiclesRestrictionsmassArgs = {
 
 /** Filter which can be applied to retrieve the station list action. */
 export type StationListFilter = {
-  /** Powers in kWh. */
+  /** Powers in kW. */
   powers?: Maybe<Array<Maybe<Scalars["Float"]>>>;
   /** Amenities available near a station. */
   amenities?: Maybe<Array<Maybe<Amenities>>>;
@@ -5709,11 +7092,11 @@ export type StationRoaming = {
 
 /** The station speed type. */
 export enum StationSpeedType {
-  /** Slow charging (below 43 kWh). */
+  /** Slow charging (below 43 kW). */
   SLOW = "slow",
-  /** Fast charging stations (above 43 kWh and below 150 kWh). */
+  /** Fast charging stations (above 43 kW and below 150 kW). */
   FAST = "fast",
-  /** Ultra fast charging stations (above 150 kWh). */
+  /** Ultra fast charging stations (above 150 kW). */
   TURBO = "turbo"
 }
 
@@ -5784,6 +7167,8 @@ export type Subscription = {
   navigationUpdatedById?: Maybe<Navigation>;
   /** Subscription for a specific route was updated in the system event */
   routeUpdatedById?: Maybe<Route>;
+  /** [BETA] Subscription for a specific route was updated in the system event */
+  route: RouteResponse;
 };
 
 export type SubscriptionconnectedVehicleArgs = {
@@ -5802,6 +7187,10 @@ export type SubscriptionrouteUpdatedByIdArgs = {
   id: Scalars["ID"];
 };
 
+export type SubscriptionrouteArgs = {
+  id: Scalars["ID"];
+};
+
 export type Telemetry = {
   /** Value of the auxiliary power consumption of the vehicle. */
   auxiliary_consumption?: Maybe<Scalars["Float"]>;
@@ -5948,6 +7337,7 @@ export type TelemetryInput = {
   custom?: Maybe<Scalars["JSON"]>;
 };
 
+/** Telemetry input sources. */
 export enum TelemetryInputSource {
   /** Manually inputted value. */
   MANUAL = "manual",
@@ -5969,6 +7359,7 @@ export type TemperatureInput = {
   type: TemperatureUnit;
 };
 
+/** Temperature unit. */
 export enum TemperatureUnit {
   /** Return the temperature in Celsius. */
   CELSIUS = "Celsius",
@@ -5976,13 +7367,22 @@ export enum TemperatureUnit {
   FAHRENHEIT = "Fahrenheit"
 }
 
+export type TirePressure = {
+  /** Values for the tire pressure, starting from the front side right to left and to the rear (FR, FL, RL, RR). */
+  value: Array<Scalars["Float"]>;
+  /** Type of the value of pressure. */
+  type: PressureUnit;
+  /** Source of inputted data. */
+  source: TelemetryInputSource;
+};
+
 export type TirePressureInput = {
   /** Values for the tire pressure, starting from the front side right to left and to the rear. */
   value: Array<Scalars["Float"]>;
   /** Type of the value of pressure. */
   type: PressureUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
 };
 
 export enum TorqueUnit {
@@ -5992,13 +7392,31 @@ export enum TorqueUnit {
   FOOT_POUND = "foot_pound"
 }
 
+export type TotalCargoWeight = {
+  /** Value of the current weight of the cargo. */
+  value: Scalars["Float"];
+  /** Type of the current weight of the cargo. */
+  type: WeightUnit;
+  /** Source of inputted data. */
+  source: TelemetryInputSource;
+};
+
 export type TotalCargoWeightInput = {
   /** Value of the current weight of the cargo. */
   value: Scalars["Float"];
   /** Type of the current weight of the cargo. */
   type: WeightUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
+};
+
+export type TotalOccupantWeight = {
+  /** Value of the current weight of the occupants. */
+  value: Scalars["Float"];
+  /** Type of the current weight of the occupants. */
+  type: WeightUnit;
+  /** Source of inputted data. */
+  source: TelemetryInputSource;
 };
 
 export type TotalOccupantWeightInput = {
@@ -6007,7 +7425,7 @@ export type TotalOccupantWeightInput = {
   /** Type of the current weight of the occupants. */
   type: WeightUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
 };
 
 export enum TurningCircleUnit {
@@ -7261,7 +8679,7 @@ export type VehiclePremiumRoutingfuel_consumptionArgs = {
 };
 
 export type VehiclePremiumRoutingConsumption = {
-  /** The amount of energy, in kWh, used by the auxiliary systems of the vehicle in a hour, like media box, etc */
+  /** The amount of energy, in kWh, used by the auxiliary systems of the vehicle in an hour, like media box, etc */
   auxiliary?: Maybe<Scalars["Float"]>;
   /**
    * Consumption, in kWh, of the auxiliaries.
@@ -7417,27 +8835,24 @@ export type VehicleRouting = {
   fast_charging_support: Scalars["Boolean"];
 };
 
+export type VehicleSpeed = {
+  /** Value of the vehicle speed. */
+  value: Scalars["Float"];
+  /** Type of the vehicle speed. */
+  type: SpeedUnit;
+  /** Source of inputted data. */
+  source: TelemetryInputSource;
+};
+
 export type VehicleSpeedInput = {
   /** Value of the vehicle speed. */
   value: Scalars["Float"];
   /** Type of the vehicle speed. */
   type: SpeedUnit;
   /** Source of inputted data, defaults to 'manual'. */
-  source?: Maybe<TelemetryInputSource>;
+  source?: TelemetryInputSource;
 };
 
-/** Status of a vehicle. */
-export enum VehicleStatus {
-  /** Is being reviewed by a human operator. */
-  DRAFT = "draft",
-  /** Is public and can be used by a customer. */
-  PUBLIC = "public",
-  /** Is private and can be used by a human operator. */
-  PRIVATE = "private",
-  /** Is archived and can not be used. */
-  ARCHIVED = "archived"
-}
-
 export type VehicleToEverything = {
   /** Information about Vehicle-to-Load. */
   vehicle_to_load?: Maybe<VehicleToEverythingLoad>;
@@ -7517,6 +8932,7 @@ export enum VolumeUnit {
   CUBIC_FOOT = "cubic_foot"
 }
 
+/** Weight unit. */
 export enum WeightUnit {
   /** Return the weight in kilograms. */
   KILOGRAM = "kilogram",