@chargetrip/types 1.30.0 → 1.30.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +234 -0
- package/README.md +1 -1
- package/dist/browser/index.js +1 -1
- package/dist/browser/index.js.map +1 -1
- package/dist/node/index.js +78 -3
- package/dist/node/index.js.map +1 -1
- package/dist/react-native/graphql.js +78 -3
- package/dist/react-native/graphql.js.map +1 -1
- package/dist/ts/graphql.d.ts +252 -82
- package/graphql.schema.json +3910 -3653
- package/package.json +3 -2
- package/src/graphql.ts +1300 -1270
package/src/graphql.ts
CHANGED
|
@@ -29,31 +29,31 @@ export type Scalars = {
|
|
|
29
29
|
};
|
|
30
30
|
|
|
31
31
|
export enum AccessType {
|
|
32
|
-
PRIVATE = "Private",
|
|
33
32
|
PUBLIC = "Public",
|
|
34
|
-
RESTRICTED = "Restricted"
|
|
33
|
+
RESTRICTED = "Restricted",
|
|
34
|
+
PRIVATE = "Private"
|
|
35
35
|
}
|
|
36
36
|
|
|
37
37
|
/** Information about an address */
|
|
38
38
|
export type Address = {
|
|
39
|
-
/** City */
|
|
40
|
-
city?: Maybe<Scalars["String"]>;
|
|
41
39
|
/** Continent code (2 letters) */
|
|
42
40
|
continent?: Maybe<Scalars["String"]>;
|
|
43
41
|
/** Country code (2 letters) */
|
|
44
42
|
country?: Maybe<Scalars["String"]>;
|
|
45
43
|
/** County code (2 letters) */
|
|
46
44
|
county?: Maybe<Scalars["String"]>;
|
|
47
|
-
/**
|
|
48
|
-
|
|
45
|
+
/** City */
|
|
46
|
+
city?: Maybe<Scalars["String"]>;
|
|
47
|
+
/** Street name */
|
|
48
|
+
street?: Maybe<Scalars["String"]>;
|
|
49
49
|
/** Street number */
|
|
50
50
|
number?: Maybe<Scalars["String"]>;
|
|
51
51
|
/** Postal code of a location */
|
|
52
52
|
postalCode?: Maybe<Scalars["String"]>;
|
|
53
|
-
/** Street name */
|
|
54
|
-
street?: Maybe<Scalars["String"]>;
|
|
55
53
|
/** String composed of 3 words which represent the location of an address on the globe. More details: http://w3w.co/<what3Words> */
|
|
56
54
|
what3Words?: Maybe<Scalars["String"]>;
|
|
55
|
+
/** Human-readable address of a location */
|
|
56
|
+
formattedAddress?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
57
57
|
};
|
|
58
58
|
|
|
59
59
|
export enum AdhocAuthorisationMethod {
|
|
@@ -69,211 +69,211 @@ export enum AdhocAuthorisationMethod {
|
|
|
69
69
|
|
|
70
70
|
/** Amenities available near a station */
|
|
71
71
|
export enum Amenities {
|
|
72
|
-
BATHROOM = "bathroom",
|
|
73
|
-
COFFEE = "coffee",
|
|
74
|
-
HOTEL = "hotel",
|
|
75
|
-
MUSEUM = "museum",
|
|
76
72
|
PARK = "park",
|
|
77
|
-
PHARMACY = "pharmacy",
|
|
78
|
-
PLAYGROUND = "playground",
|
|
79
73
|
RESTAURANT = "restaurant",
|
|
74
|
+
MUSEUM = "museum",
|
|
75
|
+
COFFEE = "coffee",
|
|
76
|
+
HOTEL = "hotel",
|
|
80
77
|
SHOPPING = "shopping",
|
|
81
|
-
|
|
78
|
+
BATHROOM = "bathroom",
|
|
79
|
+
SUPERMARKET = "supermarket",
|
|
80
|
+
PLAYGROUND = "playground",
|
|
81
|
+
PHARMACY = "pharmacy"
|
|
82
82
|
}
|
|
83
83
|
|
|
84
84
|
/** The amenity model */
|
|
85
85
|
export type Amenity = {
|
|
86
|
-
/** Embedded Address */
|
|
87
|
-
address?: Maybe<Address>;
|
|
88
|
-
/** Date and time when an amenity was created */
|
|
89
|
-
createdAt?: Maybe<Scalars["String"]>;
|
|
90
|
-
/** Computed distance between station and amenity */
|
|
91
|
-
distance?: Maybe<Scalars["Int"]>;
|
|
92
|
-
/** ID provided by an amenity data source as the row ID */
|
|
93
|
-
externalId?: Maybe<Scalars["String"]>;
|
|
94
|
-
/** Full path URL to amenity foursquare page */
|
|
95
|
-
foursquareUrl?: Maybe<Scalars["String"]>;
|
|
96
86
|
/** Unique amenity ID */
|
|
97
87
|
id?: Maybe<Scalars["ID"]>;
|
|
98
|
-
/**
|
|
99
|
-
|
|
88
|
+
/** ID provided by an amenity data source as the row ID */
|
|
89
|
+
externalId?: Maybe<Scalars["String"]>;
|
|
100
90
|
/** Name of an amenity */
|
|
101
91
|
name?: Maybe<Scalars["String"]>;
|
|
102
|
-
/**
|
|
103
|
-
|
|
92
|
+
/** Geo location coordinates. This is a GeoJSON Point */
|
|
93
|
+
location?: Maybe<Point>;
|
|
94
|
+
/** Embedded Address */
|
|
95
|
+
address?: Maybe<Address>;
|
|
104
96
|
/** Type of amenity. An amenity can belong to multiple categories */
|
|
105
97
|
type?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
98
|
+
/** Rating of an amenity, the value will be between 0.0 and 10.0. If no rating has been given, the value will be set to null */
|
|
99
|
+
rating?: Maybe<Scalars["Float"]>;
|
|
100
|
+
/** Computed distance between station and amenity */
|
|
101
|
+
distance?: Maybe<Scalars["Int"]>;
|
|
102
|
+
/** Full path URL to amenity foursquare page */
|
|
103
|
+
foursquareUrl?: Maybe<Scalars["String"]>;
|
|
104
|
+
/** Date and time when an amenity was created */
|
|
105
|
+
createdAt?: Maybe<Scalars["String"]>;
|
|
106
106
|
/** Date and time when an amenity was last updated */
|
|
107
107
|
updatedAt?: Maybe<Scalars["String"]>;
|
|
108
108
|
};
|
|
109
109
|
|
|
110
110
|
/** Amenities stats model */
|
|
111
111
|
export type AmenityStats = {
|
|
112
|
-
/** The total number of stations with the specified amenity */
|
|
113
|
-
total?: Maybe<Scalars["Int"]>;
|
|
114
112
|
/** The amenity type */
|
|
115
113
|
type?: Maybe<Scalars["String"]>;
|
|
114
|
+
/** The total number of stations with the specified amenity */
|
|
115
|
+
total?: Maybe<Scalars["Int"]>;
|
|
116
116
|
};
|
|
117
117
|
|
|
118
118
|
/** The type of the batter value */
|
|
119
119
|
export enum BatteryInputType {
|
|
120
|
-
KM = "km",
|
|
121
120
|
KWH = "kwh",
|
|
121
|
+
KM = "km",
|
|
122
122
|
MILES = "miles",
|
|
123
123
|
PERCENTAGE = "percentage"
|
|
124
124
|
}
|
|
125
125
|
|
|
126
126
|
/** Output of a car query */
|
|
127
127
|
export type Car = {
|
|
128
|
-
/**
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
128
|
+
/** Cars unique ID */
|
|
129
|
+
id?: Maybe<Scalars["ID"]>;
|
|
130
|
+
/** Naming of a car */
|
|
131
|
+
naming?: Maybe<CarNaming>;
|
|
132
|
+
/** Available connectors for a car */
|
|
133
|
+
connectors?: Maybe<Array<Maybe<CarPlug>>>;
|
|
133
134
|
/** List of adapters of connectors available for a car */
|
|
134
135
|
adapters?: Maybe<Array<Maybe<CarPlug>>>;
|
|
135
|
-
/** Availability of a car */
|
|
136
|
-
availability?: Maybe<CarAvailability>;
|
|
137
136
|
/** Battery of a car */
|
|
138
137
|
battery?: Maybe<CarBattery>;
|
|
138
|
+
/** Body of a car */
|
|
139
|
+
body?: Maybe<CarBody>;
|
|
140
|
+
/** Availability of a car */
|
|
141
|
+
availability?: Maybe<CarAvailability>;
|
|
142
|
+
/** Performance of a car */
|
|
143
|
+
performance?: Maybe<CarPerformance>;
|
|
144
|
+
/** Range of a car */
|
|
145
|
+
range?: Maybe<CarRange>;
|
|
146
|
+
/** Media of a car */
|
|
147
|
+
media?: Maybe<CarMedia>;
|
|
148
|
+
/** Routing of a car */
|
|
149
|
+
routing?: Maybe<CarRouting>;
|
|
150
|
+
/** Information about vehicle connectivity */
|
|
151
|
+
connect?: Maybe<Connect>;
|
|
139
152
|
/**
|
|
140
|
-
*
|
|
141
|
-
* @deprecated
|
|
142
|
-
*/
|
|
143
|
-
batteryEfficiency?: Maybe<CarBatteryEfficiency>;
|
|
144
|
-
/**
|
|
145
|
-
* Full battery capacity in kWh
|
|
146
|
-
* @deprecated In favor of battery.full_kwh
|
|
153
|
+
* ID provided by a car data source as the row ID
|
|
154
|
+
* @deprecated Will be removed in the future
|
|
147
155
|
*/
|
|
148
|
-
|
|
156
|
+
externalId?: Maybe<Scalars["String"]>;
|
|
149
157
|
/**
|
|
150
|
-
*
|
|
151
|
-
* @deprecated In favor of
|
|
158
|
+
* Car manufacturer
|
|
159
|
+
* @deprecated In favor of naming.make
|
|
152
160
|
*/
|
|
153
|
-
|
|
154
|
-
/** Body of a car */
|
|
155
|
-
body?: Maybe<CarBody>;
|
|
161
|
+
make?: Maybe<Scalars["String"]>;
|
|
156
162
|
/**
|
|
157
163
|
* Car model
|
|
158
164
|
* @deprecated In favor of naming.model
|
|
159
165
|
*/
|
|
160
166
|
carModel?: Maybe<Scalars["String"]>;
|
|
167
|
+
/**
|
|
168
|
+
* Car edition
|
|
169
|
+
* @deprecated In favor of naming.version
|
|
170
|
+
*/
|
|
171
|
+
edition?: Maybe<Scalars["String"]>;
|
|
161
172
|
/**
|
|
162
173
|
* Car model edition. Added by Chargetrip as an alternative for when a car manufacturer does not provide an edition name, or uses the same edition name across all trims or consecutive years
|
|
163
174
|
* @deprecated In favor of naming.chargetrip_version
|
|
164
175
|
*/
|
|
165
176
|
chargetripEdition?: Maybe<Scalars["String"]>;
|
|
177
|
+
/**
|
|
178
|
+
* Car version
|
|
179
|
+
* @deprecated In favor of naming.edition
|
|
180
|
+
*/
|
|
181
|
+
version?: Maybe<Scalars["String"]>;
|
|
166
182
|
/**
|
|
167
183
|
* Chargetrip's custom real world range provides a carefully calculated display range for all EV models. This is based on our own research and driving data
|
|
168
184
|
* @deprecated In favor of range.chargetrip_range
|
|
169
185
|
*/
|
|
170
186
|
chargetripRange?: Maybe<ChargetripRange>;
|
|
171
187
|
/**
|
|
172
|
-
*
|
|
173
|
-
* @deprecated
|
|
174
|
-
*/
|
|
175
|
-
chargingOffset?: Maybe<Scalars["JSON"]>;
|
|
176
|
-
/** Information about vehicle connectivity */
|
|
177
|
-
connect?: Maybe<Connect>;
|
|
178
|
-
/** Available connectors for a car */
|
|
179
|
-
connectors?: Maybe<Array<Maybe<CarPlug>>>;
|
|
180
|
-
/**
|
|
181
|
-
* Extra consumption model
|
|
182
|
-
* @deprecated In favor of routing.consumption
|
|
188
|
+
* Cars that support fast charging have a minimum charging speed of 43 kWh
|
|
189
|
+
* @deprecated In favor of routing.fast_charging_support
|
|
183
190
|
*/
|
|
184
|
-
|
|
191
|
+
fastChargingSupport?: Maybe<Scalars["Boolean"]>;
|
|
185
192
|
/**
|
|
186
|
-
*
|
|
187
|
-
* @deprecated In favor of
|
|
193
|
+
* Current production mode of a car
|
|
194
|
+
* @deprecated In favor of availability.status
|
|
188
195
|
*/
|
|
189
|
-
|
|
196
|
+
mode?: Maybe<CarMode>;
|
|
190
197
|
/**
|
|
191
|
-
*
|
|
192
|
-
* @deprecated
|
|
198
|
+
* Number of seats
|
|
199
|
+
* @deprecated In favor of body.seats
|
|
193
200
|
*/
|
|
194
|
-
|
|
201
|
+
seats?: Maybe<Scalars["Int"]>;
|
|
195
202
|
/**
|
|
196
|
-
*
|
|
197
|
-
* @deprecated In favor of
|
|
203
|
+
* Weight in kg
|
|
204
|
+
* @deprecated In favor of body.weight
|
|
198
205
|
*/
|
|
199
|
-
|
|
206
|
+
weight?: Maybe<Scalars["Float"]>;
|
|
200
207
|
/**
|
|
201
208
|
* Height in mm
|
|
202
209
|
* @deprecated In favor of body.height
|
|
203
210
|
*/
|
|
204
211
|
height?: Maybe<Scalars["Int"]>;
|
|
205
|
-
/** Cars unique ID */
|
|
206
|
-
id?: Maybe<Scalars["ID"]>;
|
|
207
212
|
/**
|
|
208
|
-
*
|
|
209
|
-
* @deprecated In favor of
|
|
213
|
+
* Width in mm
|
|
214
|
+
* @deprecated In favor of body.width
|
|
210
215
|
*/
|
|
211
|
-
|
|
216
|
+
width?: Maybe<Scalars["Int"]>;
|
|
212
217
|
/**
|
|
213
|
-
*
|
|
214
|
-
* @deprecated In favor of
|
|
218
|
+
* Usable battery capacity in kWh
|
|
219
|
+
* @deprecated In favor of battery.usable_kwh
|
|
215
220
|
*/
|
|
216
|
-
|
|
221
|
+
batteryUsableKwh?: Maybe<Scalars["Float"]>;
|
|
217
222
|
/**
|
|
218
|
-
*
|
|
219
|
-
* @deprecated In favor of
|
|
223
|
+
* Full battery capacity in kWh
|
|
224
|
+
* @deprecated In favor of battery.full_kwh
|
|
220
225
|
*/
|
|
221
|
-
|
|
222
|
-
/** Media of a car */
|
|
223
|
-
media?: Maybe<CarMedia>;
|
|
226
|
+
batteryFullKwh?: Maybe<Scalars["Float"]>;
|
|
224
227
|
/**
|
|
225
|
-
*
|
|
226
|
-
* @deprecated In favor of
|
|
228
|
+
* Battery efficiency in the city, highway and combined depending on weather conditions
|
|
229
|
+
* @deprecated In favor of efficiency
|
|
227
230
|
*/
|
|
228
|
-
|
|
229
|
-
/** Naming of a car */
|
|
230
|
-
naming?: Maybe<CarNaming>;
|
|
231
|
-
/** Performance of a car */
|
|
232
|
-
performance?: Maybe<CarPerformance>;
|
|
231
|
+
batteryEfficiency?: Maybe<CarBatteryEfficiency>;
|
|
233
232
|
/**
|
|
234
|
-
*
|
|
235
|
-
* @deprecated In favor of
|
|
233
|
+
* Acceleration time from 0 to 100 km/h
|
|
234
|
+
* @deprecated In favor of performance.acceleration
|
|
236
235
|
*/
|
|
237
|
-
|
|
236
|
+
acceleration?: Maybe<Scalars["Float"]>;
|
|
237
|
+
/**
|
|
238
|
+
* Maximum car speed in km/h
|
|
239
|
+
* @deprecated In favor of performance.top_speed
|
|
240
|
+
*/
|
|
241
|
+
topSpeed?: Maybe<Scalars["Float"]>;
|
|
238
242
|
/**
|
|
239
243
|
* Power of a car in Kw
|
|
240
244
|
* @deprecated In favor of drivetrain.power
|
|
241
245
|
*/
|
|
242
246
|
power?: Maybe<Scalars["Float"]>;
|
|
243
|
-
/** Range of a car */
|
|
244
|
-
range?: Maybe<CarRange>;
|
|
245
|
-
/** Routing of a car */
|
|
246
|
-
routing?: Maybe<CarRouting>;
|
|
247
247
|
/**
|
|
248
|
-
*
|
|
249
|
-
* @deprecated In favor of
|
|
248
|
+
* Engine torque
|
|
249
|
+
* @deprecated In favor of drivetrain.torque
|
|
250
250
|
*/
|
|
251
|
-
|
|
251
|
+
torque?: Maybe<Scalars["Float"]>;
|
|
252
252
|
/**
|
|
253
|
-
*
|
|
254
|
-
* @deprecated In favor of
|
|
253
|
+
* Extra consumption model
|
|
254
|
+
* @deprecated In favor of routing.consumption
|
|
255
255
|
*/
|
|
256
|
-
|
|
256
|
+
consumption?: Maybe<CarExtraConsumption>;
|
|
257
257
|
/**
|
|
258
|
-
*
|
|
259
|
-
* @deprecated In favor of
|
|
258
|
+
* Amount of petrol a similar petrol car would consume per 100 km
|
|
259
|
+
* @deprecated In favor of routing.petrol_consumption
|
|
260
260
|
*/
|
|
261
|
-
|
|
261
|
+
petrolConsumption?: Maybe<Scalars["Float"]>;
|
|
262
262
|
/**
|
|
263
|
-
*
|
|
264
|
-
* @deprecated
|
|
263
|
+
* A list of offset data for different charging speeds
|
|
264
|
+
* @deprecated You will receive null values
|
|
265
265
|
*/
|
|
266
|
-
|
|
266
|
+
chargingOffset?: Maybe<Scalars["JSON"]>;
|
|
267
267
|
/**
|
|
268
|
-
*
|
|
269
|
-
* @deprecated In favor of
|
|
268
|
+
* Images of a car
|
|
269
|
+
* @deprecated In favor of media.image_list
|
|
270
270
|
*/
|
|
271
|
-
|
|
271
|
+
images?: Maybe<Array<Maybe<CarImage>>>;
|
|
272
272
|
/**
|
|
273
|
-
*
|
|
274
|
-
* @deprecated In favor of
|
|
273
|
+
* Images of a car in structured data
|
|
274
|
+
* @deprecated In favor of media.image or media.brand
|
|
275
275
|
*/
|
|
276
|
-
|
|
276
|
+
imagesData?: Maybe<CarImageData>;
|
|
277
277
|
};
|
|
278
278
|
|
|
279
279
|
export type CarAvailability = {
|
|
@@ -295,20 +295,20 @@ export type CarAvailability = {
|
|
|
295
295
|
};
|
|
296
296
|
|
|
297
297
|
export type CarBattery = {
|
|
298
|
-
/** Full battery capacity in kWh */
|
|
299
|
-
full_kwh?: Maybe<Scalars["Float"]>;
|
|
300
298
|
/** Usable battery capacity in kWh */
|
|
301
299
|
usable_kwh?: Maybe<Scalars["Float"]>;
|
|
300
|
+
/** Full battery capacity in kWh */
|
|
301
|
+
full_kwh?: Maybe<Scalars["Float"]>;
|
|
302
302
|
};
|
|
303
303
|
|
|
304
304
|
/** Deprecated */
|
|
305
305
|
export type CarBatteryEfficiency = {
|
|
306
306
|
/** Average efficiency measured in kWh/100 km */
|
|
307
307
|
average?: Maybe<Scalars["Float"]>;
|
|
308
|
-
/** Best conditions are based on 23°C and no use of A/C, measured in kWh/100 km */
|
|
309
|
-
best?: Maybe<CarEstimationData>;
|
|
310
308
|
/** Worst conditions are based on -10°C and use of heating, measured in kWh/100 km */
|
|
311
309
|
worst?: Maybe<CarEstimationData>;
|
|
310
|
+
/** Best conditions are based on 23°C and no use of A/C, measured in kWh/100 km */
|
|
311
|
+
best?: Maybe<CarEstimationData>;
|
|
312
312
|
};
|
|
313
313
|
|
|
314
314
|
/** Battery field estimated */
|
|
@@ -324,30 +324,30 @@ export enum CarBatteryFieldEstimations {
|
|
|
324
324
|
}
|
|
325
325
|
|
|
326
326
|
export type CarBody = {
|
|
327
|
+
/** Width with folded mirrors in mm */
|
|
328
|
+
width?: Maybe<Scalars["Int"]>;
|
|
327
329
|
/** Height (average height for adjustable suspensions) in mm */
|
|
328
330
|
height?: Maybe<Scalars["Int"]>;
|
|
329
|
-
/** Number of seats */
|
|
330
|
-
seats?: Maybe<Scalars["Int"]>;
|
|
331
331
|
/** Weight Unladen EU) in kg */
|
|
332
332
|
weight?: Maybe<Scalars["Int"]>;
|
|
333
|
-
/**
|
|
334
|
-
|
|
333
|
+
/** Number of seats */
|
|
334
|
+
seats?: Maybe<Scalars["Int"]>;
|
|
335
335
|
};
|
|
336
336
|
|
|
337
337
|
/** Deprecated */
|
|
338
338
|
export type CarConsumption = {
|
|
339
|
-
/** Best conditions are based on 23°C and no use of A/C */
|
|
340
|
-
best?: Maybe<Scalars["Float"]>;
|
|
341
339
|
/** Worst conditions are based on -10°C and use of heating */
|
|
342
340
|
worst?: Maybe<Scalars["Float"]>;
|
|
341
|
+
/** Best conditions are based on 23°C and no use of A/C */
|
|
342
|
+
best?: Maybe<Scalars["Float"]>;
|
|
343
343
|
};
|
|
344
344
|
|
|
345
345
|
/** The consumption of the car */
|
|
346
346
|
export type CarConsumptionInput = {
|
|
347
|
-
/** Best conditions are based on 23°C and no use of A/C */
|
|
348
|
-
best?: Maybe<Scalars["Float"]>;
|
|
349
347
|
/** Worst conditions are based on -10°C and use of heating */
|
|
350
348
|
worst?: Maybe<Scalars["Float"]>;
|
|
349
|
+
/** Best conditions are based on 23°C and no use of A/C */
|
|
350
|
+
best?: Maybe<Scalars["Float"]>;
|
|
351
351
|
};
|
|
352
352
|
|
|
353
353
|
/** Drivetrain */
|
|
@@ -360,12 +360,12 @@ export enum CarDrivetrain {
|
|
|
360
360
|
|
|
361
361
|
/** Deprecated */
|
|
362
362
|
export type CarEstimationData = {
|
|
363
|
+
/** Estimated battery efficiency on a highway or express roads, in km */
|
|
364
|
+
highway?: Maybe<Scalars["Float"]>;
|
|
363
365
|
/** Estimated battery efficiency on city roads, in km */
|
|
364
366
|
city?: Maybe<Scalars["Float"]>;
|
|
365
367
|
/** Estimated battery efficiency on highway and city roads combined, in km */
|
|
366
368
|
combined?: Maybe<Scalars["Float"]>;
|
|
367
|
-
/** Estimated battery efficiency on a highway or express roads, in km */
|
|
368
|
-
highway?: Maybe<Scalars["Float"]>;
|
|
369
369
|
};
|
|
370
370
|
|
|
371
371
|
/** Deprecated */
|
|
@@ -385,48 +385,48 @@ export enum CarFuel {
|
|
|
385
385
|
}
|
|
386
386
|
|
|
387
387
|
export type CarImage = {
|
|
388
|
-
/** Height of a large image in pixels */
|
|
389
|
-
height?: Maybe<Scalars["Int"]>;
|
|
390
388
|
/** Image id */
|
|
391
389
|
id?: Maybe<Scalars["ID"]>;
|
|
392
|
-
/** Height of a thumbnail image in pixels */
|
|
393
|
-
thumbnail_height?: Maybe<Scalars["Int"]>;
|
|
394
|
-
/** Full path URL of a thumbnail image */
|
|
395
|
-
thumbnail_url?: Maybe<Scalars["String"]>;
|
|
396
|
-
/** Width of a thumbnail image in pixels */
|
|
397
|
-
thumbnail_width?: Maybe<Scalars["Int"]>;
|
|
398
390
|
/** Image type */
|
|
399
391
|
type?: Maybe<CarImageType>;
|
|
400
392
|
/** Full path URL of a large image */
|
|
401
393
|
url?: Maybe<Scalars["String"]>;
|
|
394
|
+
/** Height of a large image in pixels */
|
|
395
|
+
height?: Maybe<Scalars["Int"]>;
|
|
402
396
|
/** Width of a large image in pixels */
|
|
403
397
|
width?: Maybe<Scalars["Int"]>;
|
|
398
|
+
/** Full path URL of a thumbnail image */
|
|
399
|
+
thumbnail_url?: Maybe<Scalars["String"]>;
|
|
400
|
+
/** Height of a thumbnail image in pixels */
|
|
401
|
+
thumbnail_height?: Maybe<Scalars["Int"]>;
|
|
402
|
+
/** Width of a thumbnail image in pixels */
|
|
403
|
+
thumbnail_width?: Maybe<Scalars["Int"]>;
|
|
404
404
|
};
|
|
405
405
|
|
|
406
406
|
/** Deprecated */
|
|
407
407
|
export type CarImageData = {
|
|
408
|
-
/** Full size logo of the maker of a car */
|
|
409
|
-
brand?: Maybe<CarImage>;
|
|
410
|
-
/** Thumbnail of a full size logo of the maker of a car */
|
|
411
|
-
brand_thumbnail?: Maybe<CarImage>;
|
|
412
408
|
/** Full size image of a car */
|
|
413
409
|
image?: Maybe<CarImage>;
|
|
414
410
|
/** Thumbnail of a full size image */
|
|
415
411
|
image_thumbnail?: Maybe<CarImage>;
|
|
412
|
+
/** Full size logo of the maker of a car */
|
|
413
|
+
brand?: Maybe<CarImage>;
|
|
414
|
+
/** Thumbnail of a full size logo of the maker of a car */
|
|
415
|
+
brand_thumbnail?: Maybe<CarImage>;
|
|
416
416
|
};
|
|
417
417
|
|
|
418
418
|
/** Available types of images which can be found for a car. Each type has specific image sizes */
|
|
419
419
|
export enum CarImageType {
|
|
420
|
-
/**
|
|
421
|
-
|
|
422
|
-
/** Thumbnail of a full-sized brand logo at 56x24 px */
|
|
423
|
-
BRAND_THUMBNAIL = "brand_thumbnail",
|
|
420
|
+
/** Images provided by a Car Datasource */
|
|
421
|
+
PROVIDER = "provider",
|
|
424
422
|
/** Full-sized image at 1536x864 px */
|
|
425
423
|
IMAGE = "image",
|
|
426
424
|
/** Thumbnail of a full-sized image at 131x72 px */
|
|
427
425
|
IMAGE_THUMBNAIL = "image_thumbnail",
|
|
428
|
-
/**
|
|
429
|
-
|
|
426
|
+
/** Full-sized brand (maker) logo at 768x432 px */
|
|
427
|
+
BRAND = "brand",
|
|
428
|
+
/** Thumbnail of a full-sized brand logo at 56x24 px */
|
|
429
|
+
BRAND_THUMBNAIL = "brand_thumbnail"
|
|
430
430
|
}
|
|
431
431
|
|
|
432
432
|
/** When uploading images to a car, you can select one of this types. The rest of the types are automatically generated by the system */
|
|
@@ -437,131 +437,131 @@ export enum CarImageTypeUploadable {
|
|
|
437
437
|
|
|
438
438
|
/** The output element of the carList query */
|
|
439
439
|
export type CarList = {
|
|
440
|
-
/**
|
|
441
|
-
|
|
440
|
+
/** Cars unique ID */
|
|
441
|
+
id?: Maybe<Scalars["ID"]>;
|
|
442
|
+
/** Naming of a car */
|
|
443
|
+
naming?: Maybe<CarListNaming>;
|
|
444
|
+
/** Connectors available for a car */
|
|
445
|
+
connectors?: Maybe<Array<Maybe<CarPlug>>>;
|
|
442
446
|
/** Adapters of connectors available for a car */
|
|
443
447
|
adapters?: Maybe<Array<Maybe<CarPlug>>>;
|
|
444
|
-
/** @deprecated You will receive null values */
|
|
445
|
-
auxConsumption?: Maybe<Scalars["Float"]>;
|
|
446
|
-
/** Availability of a car */
|
|
447
|
-
availability?: Maybe<CarListAvailability>;
|
|
448
448
|
/** Battery of a car */
|
|
449
449
|
battery?: Maybe<CarListBattery>;
|
|
450
|
-
/**
|
|
451
|
-
|
|
450
|
+
/** Body of a car */
|
|
451
|
+
body?: Maybe<CarListBody>;
|
|
452
|
+
/** Availability of a car */
|
|
453
|
+
availability?: Maybe<CarListAvailability>;
|
|
454
|
+
/** Range of a car */
|
|
455
|
+
range?: Maybe<CarListRange>;
|
|
456
|
+
/** Media of a car */
|
|
457
|
+
media?: Maybe<CarListMedia>;
|
|
458
|
+
/** Routing of a car */
|
|
459
|
+
routing?: Maybe<CarListRouting>;
|
|
460
|
+
/** Information about vehicle connectivity */
|
|
461
|
+
connect?: Maybe<Connect>;
|
|
452
462
|
/**
|
|
453
|
-
*
|
|
454
|
-
* @deprecated
|
|
463
|
+
* ID provided by a car data source as the row ID
|
|
464
|
+
* @deprecated Will be removed in the future
|
|
455
465
|
*/
|
|
456
|
-
|
|
466
|
+
externalId?: Maybe<Scalars["String"]>;
|
|
457
467
|
/**
|
|
458
|
-
*
|
|
459
|
-
* @deprecated In favor of
|
|
468
|
+
* Car manufacturer
|
|
469
|
+
* @deprecated In favor of naming.make
|
|
460
470
|
*/
|
|
461
|
-
|
|
462
|
-
/** @deprecated You will receive null values */
|
|
463
|
-
bmsConsumption?: Maybe<Scalars["Float"]>;
|
|
464
|
-
/** Body of a car */
|
|
465
|
-
body?: Maybe<CarListBody>;
|
|
471
|
+
make?: Maybe<Scalars["String"]>;
|
|
466
472
|
/**
|
|
467
473
|
* Car model
|
|
468
474
|
* @deprecated In favor of naming.model
|
|
469
475
|
*/
|
|
470
476
|
carModel?: Maybe<Scalars["String"]>;
|
|
477
|
+
/**
|
|
478
|
+
* Car edition
|
|
479
|
+
* @deprecated In favor of naming.version
|
|
480
|
+
*/
|
|
481
|
+
edition?: Maybe<Scalars["String"]>;
|
|
471
482
|
/**
|
|
472
483
|
* Car model edition. Added by Chargetrip as an alternative for when a car manufacturer does not provide an edition name, or uses the same edition name across all trims or consecutive years
|
|
473
484
|
* @deprecated In favor of naming.chargetrip_version
|
|
474
485
|
*/
|
|
475
486
|
chargetripEdition?: Maybe<Scalars["String"]>;
|
|
487
|
+
/**
|
|
488
|
+
* Car version
|
|
489
|
+
* @deprecated In favor of naming.edition
|
|
490
|
+
*/
|
|
491
|
+
version?: Maybe<Scalars["String"]>;
|
|
476
492
|
/**
|
|
477
493
|
* Chargetrip's custom real world range provides a carefully calculated display range for all EV models. This is based on our own research and driving data
|
|
478
494
|
* @deprecated In favor of range.chargetrip_range
|
|
479
495
|
*/
|
|
480
496
|
chargetripRange?: Maybe<ChargetripRange>;
|
|
481
|
-
/** @deprecated You will receive null values */
|
|
482
|
-
chargingOffset?: Maybe<Scalars["JSON"]>;
|
|
483
|
-
/** Information about vehicle connectivity */
|
|
484
|
-
connect?: Maybe<Connect>;
|
|
485
|
-
/** Connectors available for a car */
|
|
486
|
-
connectors?: Maybe<Array<Maybe<CarPlug>>>;
|
|
487
|
-
/** @deprecated You will receive null values */
|
|
488
|
-
consumption?: Maybe<CarExtraConsumption>;
|
|
489
|
-
/** @deprecated You will receive null values */
|
|
490
|
-
dragCoefficient?: Maybe<Scalars["Float"]>;
|
|
491
|
-
/** @deprecated You will receive null values */
|
|
492
|
-
drivelineEfficiency?: Maybe<Scalars["Float"]>;
|
|
493
|
-
/**
|
|
494
|
-
* Car edition
|
|
495
|
-
* @deprecated In favor of naming.version
|
|
496
|
-
*/
|
|
497
|
-
edition?: Maybe<Scalars["String"]>;
|
|
498
|
-
/**
|
|
499
|
-
* ID provided by a car data source as the row ID
|
|
500
|
-
* @deprecated Will be removed in the future
|
|
501
|
-
*/
|
|
502
|
-
externalId?: Maybe<Scalars["String"]>;
|
|
503
497
|
/**
|
|
504
498
|
* Cars that support fast charging have a minimum charging speed of 43 kWh
|
|
505
499
|
* @deprecated In favor of routing.fast_charging_support
|
|
506
500
|
*/
|
|
507
501
|
fastChargingSupport?: Maybe<Scalars["Boolean"]>;
|
|
508
|
-
/** @deprecated You will receive null values */
|
|
509
|
-
height?: Maybe<Scalars["Int"]>;
|
|
510
|
-
/** Cars unique ID */
|
|
511
|
-
id?: Maybe<Scalars["ID"]>;
|
|
512
|
-
/** @deprecated You will receive null values */
|
|
513
|
-
images?: Maybe<Array<Maybe<CarImage>>>;
|
|
514
|
-
/**
|
|
515
|
-
* Images of a car in structured data
|
|
516
|
-
* @deprecated In favor of media.image and media.brand
|
|
517
|
-
*/
|
|
518
|
-
imagesData?: Maybe<CarImageData>;
|
|
519
|
-
/**
|
|
520
|
-
* Car manufacturer
|
|
521
|
-
* @deprecated In favor of naming.make
|
|
522
|
-
*/
|
|
523
|
-
make?: Maybe<Scalars["String"]>;
|
|
524
|
-
/** Media of a car */
|
|
525
|
-
media?: Maybe<CarListMedia>;
|
|
526
502
|
/**
|
|
527
503
|
* Current production mode of a car
|
|
528
504
|
* @deprecated In favor of availability.status
|
|
529
505
|
*/
|
|
530
506
|
mode?: Maybe<CarMode>;
|
|
531
|
-
/** @deprecated You will receive null values */
|
|
532
|
-
motorEfficiency?: Maybe<Scalars["Float"]>;
|
|
533
|
-
/** Naming of a car */
|
|
534
|
-
naming?: Maybe<CarListNaming>;
|
|
535
|
-
/** @deprecated You will receive null values */
|
|
536
|
-
petrolConsumption?: Maybe<Scalars["Float"]>;
|
|
537
|
-
/** @deprecated You will receive null values */
|
|
538
|
-
power?: Maybe<Scalars["Float"]>;
|
|
539
|
-
/** Range of a car */
|
|
540
|
-
range?: Maybe<CarListRange>;
|
|
541
|
-
/** @deprecated You will receive null values */
|
|
542
|
-
regenEfficiency?: Maybe<Scalars["Float"]>;
|
|
543
|
-
/** Routing of a car */
|
|
544
|
-
routing?: Maybe<CarListRouting>;
|
|
545
507
|
/**
|
|
546
508
|
* Number of seats
|
|
547
509
|
* @deprecated In favor of body.seats
|
|
548
510
|
*/
|
|
549
511
|
seats?: Maybe<Scalars["Int"]>;
|
|
512
|
+
/**
|
|
513
|
+
* Usable battery capacity in kWh
|
|
514
|
+
* @deprecated In favor of battery.usable_kwh
|
|
515
|
+
*/
|
|
516
|
+
batteryUsableKwh?: Maybe<Scalars["Float"]>;
|
|
517
|
+
/**
|
|
518
|
+
* Full battery capacity in kWh
|
|
519
|
+
* @deprecated In favor of battery.full_kwh
|
|
520
|
+
*/
|
|
521
|
+
batteryFullKwh?: Maybe<Scalars["Float"]>;
|
|
522
|
+
/**
|
|
523
|
+
* Images of a car in structured data
|
|
524
|
+
* @deprecated In favor of media.image and media.brand
|
|
525
|
+
*/
|
|
526
|
+
imagesData?: Maybe<CarImageData>;
|
|
550
527
|
/** @deprecated You will receive null values */
|
|
551
|
-
|
|
528
|
+
power?: Maybe<Scalars["Float"]>;
|
|
529
|
+
/** @deprecated You will receive null values */
|
|
530
|
+
acceleration?: Maybe<Scalars["Float"]>;
|
|
552
531
|
/** @deprecated You will receive null values */
|
|
553
532
|
topSpeed?: Maybe<Scalars["Float"]>;
|
|
554
533
|
/** @deprecated You will receive null values */
|
|
555
534
|
torque?: Maybe<Scalars["Float"]>;
|
|
556
|
-
/**
|
|
557
|
-
|
|
558
|
-
* @deprecated In favor of naming.edition
|
|
559
|
-
*/
|
|
560
|
-
version?: Maybe<Scalars["String"]>;
|
|
535
|
+
/** @deprecated You will receive null values */
|
|
536
|
+
batteryEfficiency?: Maybe<CarBatteryEfficiency>;
|
|
561
537
|
/** @deprecated You will receive null values */
|
|
562
538
|
weight?: Maybe<Scalars["Float"]>;
|
|
563
539
|
/** @deprecated You will receive null values */
|
|
540
|
+
height?: Maybe<Scalars["Int"]>;
|
|
541
|
+
/** @deprecated You will receive null values */
|
|
564
542
|
width?: Maybe<Scalars["Int"]>;
|
|
543
|
+
/** @deprecated You will receive null values */
|
|
544
|
+
consumption?: Maybe<CarExtraConsumption>;
|
|
545
|
+
/** @deprecated You will receive null values */
|
|
546
|
+
petrolConsumption?: Maybe<Scalars["Float"]>;
|
|
547
|
+
/** @deprecated You will receive null values */
|
|
548
|
+
chargingOffset?: Maybe<Scalars["JSON"]>;
|
|
549
|
+
/** @deprecated You will receive null values */
|
|
550
|
+
auxConsumption?: Maybe<Scalars["Float"]>;
|
|
551
|
+
/** @deprecated You will receive null values */
|
|
552
|
+
bmsConsumption?: Maybe<Scalars["Float"]>;
|
|
553
|
+
/** @deprecated You will receive null values */
|
|
554
|
+
dragCoefficient?: Maybe<Scalars["Float"]>;
|
|
555
|
+
/** @deprecated You will receive null values */
|
|
556
|
+
tirePressure?: Maybe<Scalars["Float"]>;
|
|
557
|
+
/** @deprecated You will receive null values */
|
|
558
|
+
motorEfficiency?: Maybe<Scalars["Float"]>;
|
|
559
|
+
/** @deprecated You will receive null values */
|
|
560
|
+
drivelineEfficiency?: Maybe<Scalars["Float"]>;
|
|
561
|
+
/** @deprecated You will receive null values */
|
|
562
|
+
regenEfficiency?: Maybe<Scalars["Float"]>;
|
|
563
|
+
/** @deprecated You will receive null values */
|
|
564
|
+
images?: Maybe<Array<Maybe<CarImage>>>;
|
|
565
565
|
};
|
|
566
566
|
|
|
567
567
|
export type CarListAvailability = {
|
|
@@ -583,10 +583,10 @@ export type CarListAvailability = {
|
|
|
583
583
|
};
|
|
584
584
|
|
|
585
585
|
export type CarListBattery = {
|
|
586
|
-
/** Full battery capacity in kWh */
|
|
587
|
-
full_kwh?: Maybe<Scalars["Float"]>;
|
|
588
586
|
/** Usable battery capacity in kWh */
|
|
589
587
|
usable_kwh?: Maybe<Scalars["Float"]>;
|
|
588
|
+
/** Full battery capacity in kWh */
|
|
589
|
+
full_kwh?: Maybe<Scalars["Float"]>;
|
|
590
590
|
};
|
|
591
591
|
|
|
592
592
|
export type CarListBody = {
|
|
@@ -615,44 +615,42 @@ export type CarListFilter = {
|
|
|
615
615
|
};
|
|
616
616
|
|
|
617
617
|
export type CarListMedia = {
|
|
618
|
-
/** Latest maker logo of the car */
|
|
619
|
-
brand?: Maybe<CarImage>;
|
|
620
618
|
/** Latest image of the car */
|
|
621
619
|
image?: Maybe<CarImage>;
|
|
620
|
+
/** Latest maker logo of the car */
|
|
621
|
+
brand?: Maybe<CarImage>;
|
|
622
622
|
/** Latest video of the car */
|
|
623
623
|
video?: Maybe<CarVideo>;
|
|
624
624
|
};
|
|
625
625
|
|
|
626
626
|
export type CarListNaming = {
|
|
627
|
-
/** Car model version. Added by Chargetrip as an alternative for when a car manufacturer does not provide an version name, or uses the same version name across all trims or consecutive years */
|
|
628
|
-
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
629
|
-
/** Another submodel level of car */
|
|
630
|
-
edition?: Maybe<Scalars["String"]>;
|
|
631
627
|
/** Car manufacturer name */
|
|
632
628
|
make?: Maybe<Scalars["String"]>;
|
|
633
629
|
/** Car model name */
|
|
634
630
|
model?: Maybe<Scalars["String"]>;
|
|
635
631
|
/** Version, edition or submodel of car */
|
|
636
632
|
version?: Maybe<Scalars["String"]>;
|
|
633
|
+
/** Another submodel level of car */
|
|
634
|
+
edition?: Maybe<Scalars["String"]>;
|
|
635
|
+
/** Car model version. Added by Chargetrip as an alternative for when a car manufacturer does not provide an version name, or uses the same version name across all trims or consecutive years */
|
|
636
|
+
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
637
637
|
};
|
|
638
638
|
|
|
639
639
|
/** Deprecated */
|
|
640
640
|
export type CarListQuery = {
|
|
641
|
-
/** Deprecated: Not used anymore */
|
|
642
|
-
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
643
641
|
/** Deprecated: Not used anymore */
|
|
644
642
|
make?: Maybe<Scalars["String"]>;
|
|
645
643
|
/** Deprecated: Not used anymore */
|
|
646
|
-
mode?: Maybe<CarMode>;
|
|
647
|
-
/** Deprecated: Not used anymore */
|
|
648
644
|
model?: Maybe<Scalars["String"]>;
|
|
649
645
|
/** Deprecated: Not used anymore */
|
|
650
646
|
version?: Maybe<Scalars["String"]>;
|
|
647
|
+
/** Deprecated: Not used anymore */
|
|
648
|
+
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
649
|
+
/** Deprecated: Not used anymore */
|
|
650
|
+
mode?: Maybe<CarMode>;
|
|
651
651
|
};
|
|
652
652
|
|
|
653
653
|
export type CarListRange = {
|
|
654
|
-
/** @deprecated You will receive null values */
|
|
655
|
-
best?: Maybe<CarEstimationData>;
|
|
656
654
|
/**
|
|
657
655
|
* Is an index value of what we consider to be the real-world range.
|
|
658
656
|
* (Comparable to Range_Real from EV Database.) It is essentially a normalized range to display in the front-end.
|
|
@@ -662,6 +660,8 @@ export type CarListRange = {
|
|
|
662
660
|
wltp?: Maybe<Scalars["Float"]>;
|
|
663
661
|
/** @deprecated You will receive null values */
|
|
664
662
|
worst?: Maybe<CarEstimationData>;
|
|
663
|
+
/** @deprecated You will receive null values */
|
|
664
|
+
best?: Maybe<CarEstimationData>;
|
|
665
665
|
};
|
|
666
666
|
|
|
667
667
|
export type CarListRouting = {
|
|
@@ -670,46 +670,46 @@ export type CarListRouting = {
|
|
|
670
670
|
};
|
|
671
671
|
|
|
672
672
|
export type CarMedia = {
|
|
673
|
-
/** Latest maker logo */
|
|
674
|
-
brand?: Maybe<CarImage>;
|
|
675
|
-
/**
|
|
676
|
-
* URL to detail page on EV database
|
|
677
|
-
* @deprecated Will be removed in the future. Please use evdb_details_url
|
|
678
|
-
*/
|
|
679
|
-
evdb_detail_url?: Maybe<Scalars["String"]>;
|
|
680
673
|
/** URL to detail page on EV database */
|
|
681
674
|
evdb_details_url?: Maybe<Scalars["String"]>;
|
|
682
675
|
/** Latest image */
|
|
683
676
|
image?: Maybe<CarImage>;
|
|
677
|
+
/** Latest maker logo */
|
|
678
|
+
brand?: Maybe<CarImage>;
|
|
684
679
|
/** All images */
|
|
685
680
|
image_list?: Maybe<Array<Maybe<CarImage>>>;
|
|
686
681
|
/** Latest video */
|
|
687
682
|
video?: Maybe<CarVideo>;
|
|
688
683
|
/** All videos */
|
|
689
684
|
video_list?: Maybe<Array<Maybe<CarVideo>>>;
|
|
685
|
+
/**
|
|
686
|
+
* URL to detail page on EV database
|
|
687
|
+
* @deprecated Will be removed in the future. Please use evdb_details_url
|
|
688
|
+
*/
|
|
689
|
+
evdb_detail_url?: Maybe<Scalars["String"]>;
|
|
690
690
|
};
|
|
691
691
|
|
|
692
692
|
/** Mode (state) of the current production */
|
|
693
693
|
export enum CarMode {
|
|
694
|
-
/** Future releases of a car, a concept of the car, specs may change over time */
|
|
695
|
-
CONCEPT = "concept",
|
|
696
694
|
/** Old car that is no longer manufactured */
|
|
697
695
|
INDEX_ONLY = "index_only",
|
|
698
696
|
/** Car is in production and has been released */
|
|
699
|
-
PRODUCTION = "production"
|
|
697
|
+
PRODUCTION = "production",
|
|
698
|
+
/** Future releases of a car, a concept of the car, specs may change over time */
|
|
699
|
+
CONCEPT = "concept"
|
|
700
700
|
}
|
|
701
701
|
|
|
702
702
|
export type CarNaming = {
|
|
703
|
-
/** Car model version. Added by Chargetrip as an alternative for when a car manufacturer does not provide an version name, or uses the same version name across all trims or consecutive years */
|
|
704
|
-
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
705
|
-
/** Another submodel level of car */
|
|
706
|
-
edition?: Maybe<Scalars["String"]>;
|
|
707
703
|
/** Car manufacturer name */
|
|
708
704
|
make?: Maybe<Scalars["String"]>;
|
|
709
705
|
/** Car model name */
|
|
710
706
|
model?: Maybe<Scalars["String"]>;
|
|
711
707
|
/** Version, edition or submodel of car */
|
|
712
708
|
version?: Maybe<Scalars["String"]>;
|
|
709
|
+
/** Another submodel level of car */
|
|
710
|
+
edition?: Maybe<Scalars["String"]>;
|
|
711
|
+
/** Car model version. Added by Chargetrip as an alternative for when a car manufacturer does not provide an version name, or uses the same version name across all trims or consecutive years */
|
|
712
|
+
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
713
713
|
};
|
|
714
714
|
|
|
715
715
|
export type CarPerformance = {
|
|
@@ -721,67 +721,61 @@ export type CarPerformance = {
|
|
|
721
721
|
|
|
722
722
|
/** Car plug model */
|
|
723
723
|
export type CarPlug = {
|
|
724
|
-
/** Maximum electric power in kW */
|
|
725
|
-
max_electric_power?: Maybe<Scalars["Float"]>;
|
|
726
|
-
/** Usable electric power in kW */
|
|
727
|
-
power?: Maybe<Scalars["Float"]>;
|
|
728
|
-
/** Charging speed in km/h */
|
|
729
|
-
speed?: Maybe<Scalars["Int"]>;
|
|
730
724
|
/** Plug type, known as connector standard in OCPI */
|
|
731
725
|
standard?: Maybe<ConnectorType>;
|
|
726
|
+
/** Usable electric power in kW */
|
|
727
|
+
power?: Maybe<Scalars["Float"]>;
|
|
728
|
+
/** Maximum electric power in kW */
|
|
729
|
+
max_electric_power?: Maybe<Scalars["Float"]>;
|
|
732
730
|
/** Time it takes to charge from 10 to 80% with a fast charger, shown in minutes */
|
|
733
731
|
time?: Maybe<Scalars["Int"]>;
|
|
732
|
+
/** Charging speed in km/h */
|
|
733
|
+
speed?: Maybe<Scalars["Int"]>;
|
|
734
734
|
};
|
|
735
735
|
|
|
736
736
|
/** The output element of the carPremium query */
|
|
737
737
|
export type CarPremium = {
|
|
738
|
-
/**
|
|
739
|
-
|
|
740
|
-
/**
|
|
741
|
-
|
|
738
|
+
/** Unique ID of a car */
|
|
739
|
+
id?: Maybe<Scalars["ID"]>;
|
|
740
|
+
/** Internal ID of the successor car trim */
|
|
741
|
+
succesor_id?: Maybe<Scalars["String"]>;
|
|
742
|
+
/** Naming of a car */
|
|
743
|
+
naming?: Maybe<CarPremiumNaming>;
|
|
744
|
+
/** Connectors available for a car */
|
|
745
|
+
connectors?: Maybe<Array<Maybe<CarPlug>>>;
|
|
746
|
+
/** Charge details */
|
|
747
|
+
charge?: Maybe<CarPremiumCharge>;
|
|
748
|
+
/** Fast charge details */
|
|
749
|
+
fast_charge?: Maybe<CarPremiumFastCharge>;
|
|
750
|
+
/** Adapters of connectors available for a car */
|
|
751
|
+
adapters?: Maybe<Array<Maybe<CarPlug>>>;
|
|
742
752
|
/** Battery of a car */
|
|
743
753
|
battery?: Maybe<CarPremiumBattery>;
|
|
744
754
|
/** Body of a car */
|
|
745
755
|
body?: Maybe<CarPremiumBody>;
|
|
746
|
-
/**
|
|
747
|
-
|
|
748
|
-
/**
|
|
749
|
-
|
|
750
|
-
/** Connectors available for a car */
|
|
751
|
-
connectors?: Maybe<Array<Maybe<CarPlug>>>;
|
|
756
|
+
/** Availability of a car */
|
|
757
|
+
availability?: Maybe<CarPremiumAvailability>;
|
|
758
|
+
/** Pricing of a car */
|
|
759
|
+
price?: Maybe<CarPremiumPrice>;
|
|
752
760
|
/** Drivetrain of a car */
|
|
753
761
|
drivetrain?: Maybe<CarPremiumDrivetrain>;
|
|
754
|
-
/** Efficiency of a car */
|
|
755
|
-
efficiency?: Maybe<CarPremiumEfficiency>;
|
|
756
|
-
/** Fast charge details */
|
|
757
|
-
fast_charge?: Maybe<CarPremiumFastCharge>;
|
|
758
|
-
/** Unique ID of a car */
|
|
759
|
-
id?: Maybe<Scalars["ID"]>;
|
|
760
|
-
/** Media of a car */
|
|
761
|
-
media?: Maybe<CarPremiumMedia>;
|
|
762
|
-
/** Naming of a car */
|
|
763
|
-
naming?: Maybe<CarPremiumNaming>;
|
|
764
762
|
/** Performance of a car */
|
|
765
763
|
performance?: Maybe<CarPremiumPerformance>;
|
|
766
|
-
/** Pricing of a car */
|
|
767
|
-
price?: Maybe<CarPremiumPrice>;
|
|
768
764
|
/** Range of a car */
|
|
769
765
|
range?: Maybe<CarPremiumRange>;
|
|
770
|
-
/**
|
|
771
|
-
|
|
766
|
+
/** Efficiency of a car */
|
|
767
|
+
efficiency?: Maybe<CarPremiumEfficiency>;
|
|
772
768
|
/** Safety of a car */
|
|
773
769
|
safety?: Maybe<CarPremiumSafety>;
|
|
774
|
-
/**
|
|
775
|
-
|
|
770
|
+
/** Media of a car */
|
|
771
|
+
media?: Maybe<CarPremiumMedia>;
|
|
772
|
+
/** Routing of a car */
|
|
773
|
+
routing?: Maybe<CarPremiumRouting>;
|
|
774
|
+
/** Information about vehicle connectivity */
|
|
775
|
+
connect?: Maybe<Connect>;
|
|
776
776
|
};
|
|
777
777
|
|
|
778
778
|
export type CarPremiumAvailability = {
|
|
779
|
-
/** Date of introduction, mm-yyyy */
|
|
780
|
-
date_from?: Maybe<Scalars["String"]>;
|
|
781
|
-
/** Indicates if date from field is estimated */
|
|
782
|
-
date_from_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
783
|
-
/** Date last available, mm-yyyy */
|
|
784
|
-
date_to?: Maybe<Scalars["String"]>;
|
|
785
779
|
/**
|
|
786
780
|
* Availability of car
|
|
787
781
|
*
|
|
@@ -797,343 +791,349 @@ export type CarPremiumAvailability = {
|
|
|
797
791
|
* - 91 = Status uncertain, introduction date and/or pricing unclear
|
|
798
792
|
*/
|
|
799
793
|
status?: Maybe<Scalars["Int"]>;
|
|
794
|
+
/** Date of introduction, mm-yyyy */
|
|
795
|
+
date_from?: Maybe<Scalars["String"]>;
|
|
796
|
+
/** Indicates if date from field is estimated */
|
|
797
|
+
date_from_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
798
|
+
/** Date last available, mm-yyyy */
|
|
799
|
+
date_to?: Maybe<Scalars["String"]>;
|
|
800
800
|
};
|
|
801
801
|
|
|
802
802
|
export type CarPremiumBattery = {
|
|
803
|
-
/**
|
|
804
|
-
|
|
803
|
+
/** Usable battery capacity in kWh */
|
|
804
|
+
usable_kwh?: Maybe<Scalars["Float"]>;
|
|
805
805
|
/** Full battery capacity in kWh */
|
|
806
806
|
full_kwh?: Maybe<Scalars["Float"]>;
|
|
807
|
+
/** Indicates which battery fields are estimated */
|
|
808
|
+
estimated_fields?: Maybe<CarBatteryFieldEstimations>;
|
|
807
809
|
/** Battery thermal management system (active/passive, air/liquid) */
|
|
808
810
|
thermal_management_system?: Maybe<Scalars["String"]>;
|
|
809
|
-
/** Usable battery capacity in kWh */
|
|
810
|
-
usable_kwh?: Maybe<Scalars["Float"]>;
|
|
811
|
-
/** Mileage of battery warranty */
|
|
812
|
-
warranty_mileage?: Maybe<Scalars["Float"]>;
|
|
813
811
|
/** Duration of battery warranty */
|
|
814
812
|
warranty_period?: Maybe<Scalars["Float"]>;
|
|
813
|
+
/** Mileage of battery warranty */
|
|
814
|
+
warranty_mileage?: Maybe<Scalars["Float"]>;
|
|
815
815
|
};
|
|
816
816
|
|
|
817
817
|
export type CarPremiumBody = {
|
|
818
|
-
/**
|
|
819
|
-
|
|
820
|
-
/**
|
|
821
|
-
|
|
822
|
-
/** Maximum luggage capacity in l */
|
|
823
|
-
boot_capacity_max?: Maybe<Scalars["Int"]>;
|
|
824
|
-
/** Storage capacity of front trunk/under the hood (frunk) */
|
|
825
|
-
boot_front_capacity?: Maybe<Scalars["Int"]>;
|
|
818
|
+
/** Length in mm */
|
|
819
|
+
length?: Maybe<Scalars["Int"]>;
|
|
820
|
+
/** Width with folded mirrors in mm */
|
|
821
|
+
width?: Maybe<Scalars["Int"]>;
|
|
826
822
|
/** Width of vehicle in mm, including mirrors */
|
|
827
823
|
full_width?: Maybe<Scalars["Int"]>;
|
|
828
|
-
/** Indicates whether a car has roof rails as a standard */
|
|
829
|
-
has_roofrails?: Maybe<Scalars["Boolean"]>;
|
|
830
824
|
/** Height (average height for adjustable suspensions) in mm */
|
|
831
825
|
height?: Maybe<Scalars["Int"]>;
|
|
832
|
-
/** Length in mm */
|
|
833
|
-
length?: Maybe<Scalars["Int"]>;
|
|
834
|
-
/** Gross Vehicle Weight (GVWR) - (max allowed vehicle weight with payload) in kg */
|
|
835
|
-
max_gross_vehicle_weight?: Maybe<Scalars["Int"]>;
|
|
836
|
-
/** Maximum load on roof of car in kg */
|
|
837
|
-
roof_load_max?: Maybe<Scalars["Int"]>;
|
|
838
|
-
/**
|
|
839
|
-
* Indicates whether a car has roof rails as a standard
|
|
840
|
-
* @deprecated In favor of has_roofrails
|
|
841
|
-
*/
|
|
842
|
-
rooftrails?: Maybe<Scalars["Boolean"]>;
|
|
843
|
-
/** Number of seats */
|
|
844
|
-
seats?: Maybe<Scalars["Int"]>;
|
|
845
|
-
/** Segment, listed in local naming convention where applicable */
|
|
846
|
-
segment?: Maybe<Scalars["String"]>;
|
|
847
826
|
/** Indicates if length/width/height fields are estimations */
|
|
848
827
|
size_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
828
|
+
/** Wheelbase in mm */
|
|
829
|
+
wheelbase?: Maybe<Scalars["Int"]>;
|
|
830
|
+
/** Indicates if wheelbase field is estimated */
|
|
831
|
+
wheelbase_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
832
|
+
/** Weight (unladen EU) in kg */
|
|
833
|
+
weight?: Maybe<Scalars["Int"]>;
|
|
834
|
+
/** Indicates if weight field is estimated */
|
|
835
|
+
weight_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
836
|
+
/** Maximum payload allowed for vehicle in kg */
|
|
837
|
+
weight_max_payload?: Maybe<Scalars["Int"]>;
|
|
838
|
+
/** Gross Vehicle Weight (GVWR) - (max allowed vehicle weight with payload) in kg */
|
|
839
|
+
max_gross_vehicle_weight?: Maybe<Scalars["Int"]>;
|
|
840
|
+
/** Standard luggage capacity in l */
|
|
841
|
+
boot_capacity?: Maybe<Scalars["Int"]>;
|
|
842
|
+
/** Storage capacity of front trunk/under the hood (frunk) */
|
|
843
|
+
boot_front_capacity?: Maybe<Scalars["Int"]>;
|
|
844
|
+
/** Maximum luggage capacity in l */
|
|
845
|
+
boot_capacity_max?: Maybe<Scalars["Int"]>;
|
|
849
846
|
/** Indicates if a tow hitch/towbar can be fitted according to vehicle homologation */
|
|
850
847
|
tow_hitch_compatible?: Maybe<Scalars["Boolean"]>;
|
|
848
|
+
/** Maximum unbraked towing weight in kg */
|
|
849
|
+
tow_weight_unbraked?: Maybe<Scalars["Int"]>;
|
|
851
850
|
/** Maximum braked towing weight in kg */
|
|
852
851
|
tow_weight_braked?: Maybe<Scalars["Int"]>;
|
|
853
852
|
/** Indicates if tow weight fields are estimations */
|
|
854
853
|
tow_weight_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
855
|
-
/** Maximum unbraked towing weight in kg */
|
|
856
|
-
tow_weight_unbraked?: Maybe<Scalars["Int"]>;
|
|
857
854
|
/** Maximum vertical load / noseweight on tow hitch according to vehicle homologation */
|
|
858
855
|
tow_weight_vertical_load?: Maybe<Scalars["Int"]>;
|
|
856
|
+
/** Maximum load on roof of car in kg */
|
|
857
|
+
roof_load_max?: Maybe<Scalars["Int"]>;
|
|
858
|
+
/** Body type, listed in local naming convention where applicable */
|
|
859
|
+
body_type?: Maybe<Scalars["String"]>;
|
|
860
|
+
/** Segment, listed in local naming convention where applicable */
|
|
861
|
+
segment?: Maybe<Scalars["String"]>;
|
|
862
|
+
/** Number of seats */
|
|
863
|
+
seats?: Maybe<Scalars["Int"]>;
|
|
864
|
+
/** Indicates whether a car has roof rails as a standard */
|
|
865
|
+
has_roofrails?: Maybe<Scalars["Boolean"]>;
|
|
859
866
|
/** Turning circle of vehicle kerb-to-kerb */
|
|
860
867
|
turning_circle?: Maybe<Scalars["Float"]>;
|
|
861
868
|
/** Name of vehicle platform used for vehicle (often abbreviated to indicate group platforms) */
|
|
862
869
|
vehicle_platform?: Maybe<Scalars["String"]>;
|
|
863
870
|
/** Indicates if the vehicle platform used for vehicle is a dedicated battery electric vehicle platform */
|
|
864
871
|
vehicle_platform_is_dedicated?: Maybe<Scalars["Boolean"]>;
|
|
865
|
-
/**
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
weight_max_payload?: Maybe<Scalars["Int"]>;
|
|
871
|
-
/** Wheelbase in mm */
|
|
872
|
-
wheelbase?: Maybe<Scalars["Int"]>;
|
|
873
|
-
/** Indicates if wheelbase field is estimated */
|
|
874
|
-
wheelbase_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
875
|
-
/** Width with folded mirrors in mm */
|
|
876
|
-
width?: Maybe<Scalars["Int"]>;
|
|
872
|
+
/**
|
|
873
|
+
* Indicates whether a car has roof rails as a standard
|
|
874
|
+
* @deprecated In favor of has_roofrails
|
|
875
|
+
*/
|
|
876
|
+
rooftrails?: Maybe<Scalars["Boolean"]>;
|
|
877
877
|
};
|
|
878
878
|
|
|
879
879
|
export type CarPremiumCharge = {
|
|
880
|
-
/** The car alternative charge */
|
|
881
|
-
alternative?: Maybe<CarPremiumChargeAlternativeOBC>;
|
|
882
|
-
/** The car option charge */
|
|
883
|
-
option?: Maybe<CarPremiumChargeOptionOBC>;
|
|
884
880
|
/** Location of charge port */
|
|
885
881
|
plug?: Maybe<CarPremiumChargePlug>;
|
|
886
882
|
/** Location of second charge port */
|
|
887
883
|
second_plug?: Maybe<CarPremiumChargeSecondPlug>;
|
|
888
884
|
/** The car standard charge */
|
|
889
885
|
standard?: Maybe<CarPremiumChargeStandardOBC>;
|
|
886
|
+
/** The car alternative charge */
|
|
887
|
+
alternative?: Maybe<CarPremiumChargeAlternativeOBC>;
|
|
888
|
+
/** The car option charge */
|
|
889
|
+
option?: Maybe<CarPremiumChargeOptionOBC>;
|
|
890
890
|
};
|
|
891
891
|
|
|
892
892
|
export type CarPremiumChargeAlternativeOBC = {
|
|
893
|
-
/** Charging speed when charging at maximum power (standard OBC) */
|
|
894
|
-
charge_speed?: Maybe<Scalars["Int"]>;
|
|
895
|
-
/** Minutes needed to charge from 0% to 100% (standard OBC) */
|
|
896
|
-
charge_time?: Maybe<Scalars["Int"]>;
|
|
897
|
-
/** Maximum current the OBC accepts per phase to achieve maximum power (standard OBC) */
|
|
898
|
-
phase_amperage?: Maybe<Scalars["Float"]>;
|
|
899
|
-
/** Number of phases the OBC accepts to achieve maximum power (standard OBC) */
|
|
900
|
-
phases?: Maybe<Scalars["Int"]>;
|
|
901
893
|
/** Maximum power OBC can accept to charge a battery (standard OBC) */
|
|
902
894
|
power?: Maybe<Scalars["Float"]>;
|
|
895
|
+
/** Number of phases the OBC accepts to achieve maximum power (standard OBC) */
|
|
896
|
+
phases?: Maybe<Scalars["Int"]>;
|
|
897
|
+
/** Maximum current the OBC accepts per phase to achieve maximum power (standard OBC) */
|
|
898
|
+
phase_amperage?: Maybe<Scalars["Float"]>;
|
|
899
|
+
/** Minutes needed to charge from 0% to 100% (standard OBC) */
|
|
900
|
+
charge_time?: Maybe<Scalars["Int"]>;
|
|
901
|
+
/** Charging speed when charging at maximum power (standard OBC) */
|
|
902
|
+
charge_speed?: Maybe<Scalars["Int"]>;
|
|
903
903
|
/** Charging details for the standard OBC at several charging points */
|
|
904
904
|
table?: Maybe<Array<Maybe<CarPremiumChargeOBCTable>>>;
|
|
905
905
|
};
|
|
906
906
|
|
|
907
907
|
export type CarPremiumChargeOBCTable = {
|
|
908
|
-
/**
|
|
909
|
-
|
|
908
|
+
/** Voltage between phase and neutral for this EVSE (phase voltage) */
|
|
909
|
+
evse_phase_voltage?: Maybe<Scalars["Int"]>;
|
|
910
|
+
/** Current per phase for this EVSE (phase current) */
|
|
911
|
+
evse_phase_amperage?: Maybe<Scalars["Int"]>;
|
|
912
|
+
/** Number of phases for this EVSE */
|
|
913
|
+
evse_phases?: Maybe<Scalars["Int"]>;
|
|
910
914
|
/** Voltage between phase and neutral used by standard OBC (phase voltage) */
|
|
911
915
|
charge_phase_voltage?: Maybe<Scalars["Int"]>;
|
|
916
|
+
/** Current per phase used by standard OBC (phase current) */
|
|
917
|
+
charge_phase_amperage?: Maybe<Scalars["Float"]>;
|
|
912
918
|
/** Number of phases used by standard OBC */
|
|
913
919
|
charge_phases?: Maybe<Scalars["Int"]>;
|
|
914
920
|
/** Power used by standard OBC (before OBC losses) */
|
|
915
921
|
charge_power?: Maybe<Scalars["Float"]>;
|
|
916
|
-
/** Charging speed when charging at maximum power (standard OBC with this EVSE) */
|
|
917
|
-
charge_speed?: Maybe<Scalars["Int"]>;
|
|
918
922
|
/** Minutes needed to charge from 0% to 100% (standard OBC with this EVSE) */
|
|
919
923
|
charge_time?: Maybe<Scalars["Int"]>;
|
|
920
|
-
/**
|
|
921
|
-
|
|
922
|
-
/** Voltage between phase and neutral for this EVSE (phase voltage) */
|
|
923
|
-
evse_phase_voltage?: Maybe<Scalars["Int"]>;
|
|
924
|
-
/** Number of phases for this EVSE */
|
|
925
|
-
evse_phases?: Maybe<Scalars["Int"]>;
|
|
924
|
+
/** Charging speed when charging at maximum power (standard OBC with this EVSE) */
|
|
925
|
+
charge_speed?: Maybe<Scalars["Int"]>;
|
|
926
926
|
};
|
|
927
927
|
|
|
928
928
|
export type CarPremiumChargeOptionOBC = {
|
|
929
|
-
/** Charging speed when charging at maximum power (standard OBC) */
|
|
930
|
-
charge_speed?: Maybe<Scalars["Int"]>;
|
|
931
|
-
/** Minutes needed to charge from 0% to 100% (standard OBC) */
|
|
932
|
-
charge_time?: Maybe<Scalars["Int"]>;
|
|
933
|
-
/** Maximum current the OBC accepts per phase to achieve maximum power (standard OBC) */
|
|
934
|
-
phase_amperage?: Maybe<Scalars["Float"]>;
|
|
935
|
-
/** Number of phases the OBC accepts to achieve maximum power (standard OBC) */
|
|
936
|
-
phases?: Maybe<Scalars["Int"]>;
|
|
937
929
|
/** Maximum power OBC can accept to charge a battery (standard OBC) */
|
|
938
930
|
power?: Maybe<Scalars["Float"]>;
|
|
931
|
+
/** Number of phases the OBC accepts to achieve maximum power (standard OBC) */
|
|
932
|
+
phases?: Maybe<Scalars["Int"]>;
|
|
933
|
+
/** Maximum current the OBC accepts per phase to achieve maximum power (standard OBC) */
|
|
934
|
+
phase_amperage?: Maybe<Scalars["Float"]>;
|
|
935
|
+
/** Minutes needed to charge from 0% to 100% (standard OBC) */
|
|
936
|
+
charge_time?: Maybe<Scalars["Int"]>;
|
|
937
|
+
/** Charging speed when charging at maximum power (standard OBC) */
|
|
938
|
+
charge_speed?: Maybe<Scalars["Int"]>;
|
|
939
939
|
/** Charging details for the standard OBC at several charging points */
|
|
940
940
|
table?: Maybe<Array<Maybe<CarPremiumChargeOBCTable>>>;
|
|
941
941
|
};
|
|
942
942
|
|
|
943
943
|
export type CarPremiumChargePlug = {
|
|
944
|
+
/** Type of charge port on vehicle */
|
|
945
|
+
value?: Maybe<ConnectorType>;
|
|
944
946
|
/** Indicates if value is an estimate */
|
|
945
947
|
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
946
948
|
/** Location of charge port */
|
|
947
949
|
location?: Maybe<Scalars["String"]>;
|
|
948
|
-
/** Type of charge port on vehicle */
|
|
949
|
-
value?: Maybe<ConnectorType>;
|
|
950
950
|
};
|
|
951
951
|
|
|
952
952
|
export type CarPremiumChargePower = {
|
|
953
|
-
/** Average value */
|
|
954
|
-
average?: Maybe<Scalars["Float"]>;
|
|
955
953
|
/** Maximum value */
|
|
956
954
|
max?: Maybe<Scalars["Float"]>;
|
|
955
|
+
/** Average value */
|
|
956
|
+
average?: Maybe<Scalars["Float"]>;
|
|
957
957
|
};
|
|
958
958
|
|
|
959
959
|
export type CarPremiumChargeSecondPlug = {
|
|
960
|
-
/** Indicates if second charge port is optional */
|
|
961
|
-
is_optional?: Maybe<Scalars["Boolean"]>;
|
|
962
960
|
/** Location of charge port */
|
|
963
961
|
location?: Maybe<Scalars["String"]>;
|
|
962
|
+
/** Indicates if second charge port is optional */
|
|
963
|
+
is_optional?: Maybe<Scalars["Boolean"]>;
|
|
964
964
|
};
|
|
965
965
|
|
|
966
966
|
export type CarPremiumChargeStandardOBC = {
|
|
967
|
-
/**
|
|
968
|
-
|
|
967
|
+
/** Maximum power OBC can accept to charge a battery (standard OBC) */
|
|
968
|
+
power?: Maybe<Scalars["Float"]>;
|
|
969
|
+
/** Number of phases the OBC accepts to achieve maximum power (standard OBC) */
|
|
970
|
+
phases?: Maybe<Scalars["Int"]>;
|
|
971
|
+
/** Maximum current the OBC accepts per phase to achieve maximum power (standard OBC) */
|
|
972
|
+
phase_amperage?: Maybe<Scalars["Float"]>;
|
|
969
973
|
/** Minutes needed to charge from 0% to 100% (standard OBC) */
|
|
970
974
|
charge_time?: Maybe<Scalars["Int"]>;
|
|
975
|
+
/** Charging speed when charging at maximum power (standard OBC) */
|
|
976
|
+
charge_speed?: Maybe<Scalars["Int"]>;
|
|
971
977
|
/** Indicates if Charge_Standard fields are estimated */
|
|
972
978
|
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
973
|
-
/** Maximum current the OBC accepts per phase to achieve maximum power (standard OBC) */
|
|
974
|
-
phase_amperage?: Maybe<Scalars["Float"]>;
|
|
975
|
-
/** Number of phases the OBC accepts to achieve maximum power (standard OBC) */
|
|
976
|
-
phases?: Maybe<Scalars["Int"]>;
|
|
977
|
-
/** Maximum power OBC can accept to charge a battery (standard OBC) */
|
|
978
|
-
power?: Maybe<Scalars["Float"]>;
|
|
979
979
|
/** Charging details for the standard OBC at several charging points */
|
|
980
980
|
table?: Maybe<Array<Maybe<CarPremiumChargeOBCTable>>>;
|
|
981
981
|
};
|
|
982
982
|
|
|
983
983
|
export type CarPremiumDrivetrain = {
|
|
984
|
+
/** Type of drivetrain */
|
|
985
|
+
type?: Maybe<CarDrivetrain>;
|
|
984
986
|
/** Fuel type */
|
|
985
987
|
fuel?: Maybe<CarFuel>;
|
|
986
|
-
/** Maximum (combined) power output in kw */
|
|
987
|
-
power?: Maybe<Scalars["Int"]>;
|
|
988
|
-
/** Maximum (combined) power output in horsepower (PS) */
|
|
989
|
-
power_hp?: Maybe<Scalars["Int"]>;
|
|
990
|
-
/** Indicates if power field is estimated */
|
|
991
|
-
power_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
992
988
|
/** Propulsion type */
|
|
993
989
|
propulsion?: Maybe<CarPropulsion>;
|
|
994
990
|
/** Indicates if propulsion field is estimated */
|
|
995
991
|
propulsion_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
992
|
+
/** Maximum (combined) power output in kw */
|
|
993
|
+
power?: Maybe<Scalars["Int"]>;
|
|
994
|
+
/** Indicates if power field is estimated */
|
|
995
|
+
power_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
996
|
+
/** Maximum (combined) power output in horsepower (PS) */
|
|
997
|
+
power_hp?: Maybe<Scalars["Int"]>;
|
|
996
998
|
/** Maximum (combined) torque output in newton meter */
|
|
997
999
|
torque?: Maybe<Scalars["Int"]>;
|
|
998
1000
|
/** Indicates if torque field is estimated */
|
|
999
1001
|
torque_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1000
|
-
/** Type of drivetrain */
|
|
1001
|
-
type?: Maybe<CarDrivetrain>;
|
|
1002
1002
|
};
|
|
1003
1003
|
|
|
1004
1004
|
export type CarPremiumEfficiency = {
|
|
1005
|
-
/** Rated efficiency in NEDC combined cycle */
|
|
1006
|
-
nedc?: Maybe<CarPremiumEfficiencyNEDC>;
|
|
1007
|
-
/** Car efficiency based on RealRange */
|
|
1008
|
-
real?: Maybe<CarPremiumEfficiencyReal>;
|
|
1009
1005
|
/** Rated efficiency in WLTP combined cycle */
|
|
1010
1006
|
wltp?: Maybe<CarPremiumEfficiencyWLTP>;
|
|
1011
1007
|
/** Rated efficiency in WLTP combined cycle (TEH / least efficient trim) */
|
|
1012
1008
|
wltp_teh?: Maybe<CarPremiumEfficiencyWLTPTEH>;
|
|
1009
|
+
/** Rated efficiency in NEDC combined cycle */
|
|
1010
|
+
nedc?: Maybe<CarPremiumEfficiencyNEDC>;
|
|
1011
|
+
/** Car efficiency based on RealRange */
|
|
1012
|
+
real?: Maybe<CarPremiumEfficiencyReal>;
|
|
1013
1013
|
};
|
|
1014
1014
|
|
|
1015
1015
|
export type CarPremiumEfficiencyNEDC = {
|
|
1016
|
-
/** Rated CO2 emissions in NEDC combined cycle in battery-only mode (NULL if not NEDC rated) in gr/km */
|
|
1017
|
-
co2?: Maybe<Scalars["Int"]>;
|
|
1018
|
-
/** Rated efficiency in NEDC combined cycle presented in gas equivalent, in l/100 km */
|
|
1019
|
-
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1020
1016
|
/** Rated efficiency in NEDC combined cycle in kWh/100 km */
|
|
1021
1017
|
value?: Maybe<Scalars["Float"]>;
|
|
1018
|
+
/** Rated efficiency in NEDC combined cycle presented in gas equivalent, in l/100 km */
|
|
1019
|
+
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1022
1020
|
/** Rated vehicle efficiency in NEDC combined cycle (based on value) in kWh/100 km */
|
|
1023
1021
|
vehicle?: Maybe<Scalars["Float"]>;
|
|
1024
1022
|
/** Rated vehicle efficiency in NEDC combined cycle presented in gas equivalent in l/100 km */
|
|
1025
1023
|
vehicle_fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1024
|
+
/** Rated CO2 emissions in NEDC combined cycle in battery-only mode (NULL if not NEDC rated) in gr/km */
|
|
1025
|
+
co2?: Maybe<Scalars["Int"]>;
|
|
1026
1026
|
};
|
|
1027
1027
|
|
|
1028
1028
|
export type CarPremiumEfficiencyReal = {
|
|
1029
|
-
/** Best conditions are based on 23°C and no use of A/C */
|
|
1030
|
-
best?: Maybe<CarPremiumEfficiencyRealValue>;
|
|
1031
|
-
/** Car efficiency based on RealRange presented in gas equivalent, in l/100 km */
|
|
1032
|
-
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1033
1029
|
/** Car efficiency based on RealRange (useable battery/range) in kWh/100 km */
|
|
1034
1030
|
value?: Maybe<Scalars["Float"]>;
|
|
1031
|
+
/** Car efficiency based on RealRange presented in gas equivalent, in l/100 km */
|
|
1032
|
+
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1035
1033
|
/** Worst conditions are based on -10°C and use of heating */
|
|
1036
1034
|
worst?: Maybe<CarPremiumEfficiencyRealValue>;
|
|
1035
|
+
/** Best conditions are based on 23°C and no use of A/C */
|
|
1036
|
+
best?: Maybe<CarPremiumEfficiencyRealValue>;
|
|
1037
1037
|
};
|
|
1038
1038
|
|
|
1039
1039
|
export type CarPremiumEfficiencyRealValue = {
|
|
1040
|
+
/** Estimated value on highway or express roads */
|
|
1041
|
+
highway?: Maybe<Scalars["Float"]>;
|
|
1040
1042
|
/** Estimated value on city roads */
|
|
1041
1043
|
city?: Maybe<Scalars["Float"]>;
|
|
1042
1044
|
/** Estimated combined value */
|
|
1043
1045
|
combined?: Maybe<Scalars["Float"]>;
|
|
1044
|
-
/** Estimated value on highway or express roads */
|
|
1045
|
-
highway?: Maybe<Scalars["Float"]>;
|
|
1046
1046
|
};
|
|
1047
1047
|
|
|
1048
1048
|
export type CarPremiumEfficiencyWLTP = {
|
|
1049
|
-
/** Rated CO2 emissions in WLTP combined cycle in battery-only mode (NULL if not WLTP rated) in gr/km */
|
|
1050
|
-
co2?: Maybe<Scalars["Int"]>;
|
|
1051
|
-
/** Rated efficiency in WLTP combined cycle presented in gas equivalent, in l/100 km */
|
|
1052
|
-
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1053
1049
|
/** Rated efficiency in WLTP combined cycle in kWh/100 km */
|
|
1054
1050
|
value?: Maybe<Scalars["Float"]>;
|
|
1051
|
+
/** Rated efficiency in WLTP combined cycle presented in gas equivalent, in l/100 km */
|
|
1052
|
+
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1055
1053
|
/** Rated vehicle efficiency in WLTP combined cycle (based on value) in kWh/100 km */
|
|
1056
1054
|
vehicle?: Maybe<Scalars["Float"]>;
|
|
1057
1055
|
/** Rated vehicle efficiency in WLTP combined cycle presented in gas equivalent, in l/100 km */
|
|
1058
1056
|
vehicle_fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1057
|
+
/** Rated CO2 emissions in WLTP combined cycle in battery-only mode (NULL if not WLTP rated) in gr/km */
|
|
1058
|
+
co2?: Maybe<Scalars["Int"]>;
|
|
1059
1059
|
};
|
|
1060
1060
|
|
|
1061
1061
|
export type CarPremiumEfficiencyWLTPTEH = {
|
|
1062
|
-
/** Rated CO2 emissions in WLTP TEH combined cycle in battery-only mode (NULL if not WLTP TEH rated) in gr/km */
|
|
1063
|
-
co2?: Maybe<Scalars["Int"]>;
|
|
1064
|
-
/** Rated efficiency in WLTP TEH combined cycle presented in gas equivalent, in l/100 km */
|
|
1065
|
-
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1066
1062
|
/** Rated efficiency in WLTP TEH combined cycle (TEH/least efficient trim) */
|
|
1067
1063
|
value?: Maybe<Scalars["Float"]>;
|
|
1064
|
+
/** Rated efficiency in WLTP TEH combined cycle presented in gas equivalent, in l/100 km */
|
|
1065
|
+
fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1068
1066
|
/** Rated vehicle efficiency in WLTP TEH combined cycle (based on value) in kWh/100 km */
|
|
1069
1067
|
vehicle?: Maybe<Scalars["Float"]>;
|
|
1070
1068
|
/** Rated vehicle efficiency in WLTP TEH combined cycle presented in gas equivalent, in l/100 km */
|
|
1071
1069
|
vehicle_fuel_equivalent?: Maybe<Scalars["Float"]>;
|
|
1070
|
+
/** Rated CO2 emissions in WLTP TEH combined cycle in battery-only mode (NULL if not WLTP TEH rated) in gr/km */
|
|
1071
|
+
co2?: Maybe<Scalars["Int"]>;
|
|
1072
1072
|
};
|
|
1073
1073
|
|
|
1074
1074
|
export type CarPremiumFastCharge = {
|
|
1075
|
-
/** Charging speed during fast charging from 10% to 80% (optimal conditions, fastest charger) */
|
|
1076
|
-
charge_speed?: Maybe<Scalars["Float"]>;
|
|
1077
|
-
/** Minutes needed to charge from 10% to 80%, with average charging power (optimal conditions, fastest charger) */
|
|
1078
|
-
charge_time?: Maybe<Scalars["Float"]>;
|
|
1079
|
-
/** Indicates what fields are estimated */
|
|
1080
|
-
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1081
|
-
/** Indicates if fast charge is optional in some markets/regions */
|
|
1082
|
-
is_optional?: Maybe<Scalars["Boolean"]>;
|
|
1083
1075
|
/** Location of charge port */
|
|
1084
1076
|
plug?: Maybe<CarPremiumChargePlug>;
|
|
1085
1077
|
/** Power during fast charging from 10% to 80% SoC (optimal conditions, fastest charger) */
|
|
1086
1078
|
power?: Maybe<CarPremiumChargePower>;
|
|
1079
|
+
/** Minutes needed to charge from 10% to 80%, with average charging power (optimal conditions, fastest charger) */
|
|
1080
|
+
charge_time?: Maybe<Scalars["Float"]>;
|
|
1081
|
+
/** Charging speed during fast charging from 10% to 80% (optimal conditions, fastest charger) */
|
|
1082
|
+
charge_speed?: Maybe<Scalars["Float"]>;
|
|
1083
|
+
/** Indicates if fast charge is optional in some markets/regions */
|
|
1084
|
+
is_optional?: Maybe<Scalars["Boolean"]>;
|
|
1085
|
+
/** Indicates what fields are estimated */
|
|
1086
|
+
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1087
1087
|
/** Charging details for fast charging */
|
|
1088
1088
|
table?: Maybe<Array<Maybe<CarPremiumFastChargeTable>>>;
|
|
1089
1089
|
};
|
|
1090
1090
|
|
|
1091
1091
|
export type CarPremiumFastChargeTable = {
|
|
1092
|
-
/** Indicates if average power during fast charging is limited by the vehicle */
|
|
1093
|
-
average_is_limited?: Maybe<Scalars["Boolean"]>;
|
|
1094
|
-
/** Charging speed during fast charging from 10% to 80% (optimal conditions) */
|
|
1095
|
-
charge_speed?: Maybe<Scalars["Int"]>;
|
|
1096
|
-
/** Minutes needed to charge from 10% to 80% (optimal conditions) */
|
|
1097
|
-
charge_time?: Maybe<Scalars["Int"]>;
|
|
1098
1092
|
/** Charging details for fast charging (format: ChargerPlug-ChargerPower-AC/DC) */
|
|
1099
1093
|
format?: Maybe<Scalars["String"]>;
|
|
1100
|
-
/** Indicates if maximum power during fast charging is limited by the vehicle */
|
|
1101
|
-
is_limited?: Maybe<Scalars["Boolean"]>;
|
|
1102
1094
|
/** Fast charge power */
|
|
1103
1095
|
power?: Maybe<CarPremiumChargePower>;
|
|
1096
|
+
/** Minutes needed to charge from 10% to 80% (optimal conditions) */
|
|
1097
|
+
charge_time?: Maybe<Scalars["Int"]>;
|
|
1098
|
+
/** Charging speed during fast charging from 10% to 80% (optimal conditions) */
|
|
1099
|
+
charge_speed?: Maybe<Scalars["Int"]>;
|
|
1100
|
+
/** Indicates if maximum power during fast charging is limited by the vehicle */
|
|
1101
|
+
is_limited?: Maybe<Scalars["Boolean"]>;
|
|
1102
|
+
/** Indicates if average power during fast charging is limited by the vehicle */
|
|
1103
|
+
average_is_limited?: Maybe<Scalars["Boolean"]>;
|
|
1104
1104
|
};
|
|
1105
1105
|
|
|
1106
1106
|
export type CarPremiumMedia = {
|
|
1107
|
-
/** Latest maker logo */
|
|
1108
|
-
brand?: Maybe<CarImage>;
|
|
1109
|
-
/**
|
|
1110
|
-
* URL to detail page on EV database
|
|
1111
|
-
* @deprecated Will be removed in the future. Please use evdb_details_url
|
|
1112
|
-
*/
|
|
1113
|
-
evdb_detail_url?: Maybe<Scalars["String"]>;
|
|
1114
1107
|
/** URL to detail page on EV database */
|
|
1115
1108
|
evdb_details_url?: Maybe<Scalars["String"]>;
|
|
1116
1109
|
/** Latest image */
|
|
1117
1110
|
image?: Maybe<CarImage>;
|
|
1111
|
+
/** Latest maker logo */
|
|
1112
|
+
brand?: Maybe<CarImage>;
|
|
1118
1113
|
/** All images */
|
|
1119
1114
|
image_list?: Maybe<Array<Maybe<CarImage>>>;
|
|
1120
1115
|
/** Latest video */
|
|
1121
1116
|
video?: Maybe<CarVideo>;
|
|
1122
1117
|
/** All videos */
|
|
1123
1118
|
video_list?: Maybe<Array<Maybe<CarVideo>>>;
|
|
1119
|
+
/**
|
|
1120
|
+
* URL to detail page on EV database
|
|
1121
|
+
* @deprecated Will be removed in the future. Please use evdb_details_url
|
|
1122
|
+
*/
|
|
1123
|
+
evdb_detail_url?: Maybe<Scalars["String"]>;
|
|
1124
1124
|
};
|
|
1125
1125
|
|
|
1126
1126
|
export type CarPremiumNaming = {
|
|
1127
|
-
/** Car model version. Added by Chargetrip as an alternative for when a car manufacturer does not provide a version name, or uses the same version name across all trims or consecutive years */
|
|
1128
|
-
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
1129
|
-
/** Another submodel level of car */
|
|
1130
|
-
edition?: Maybe<Scalars["String"]>;
|
|
1131
1127
|
/** Car manufacturer name */
|
|
1132
1128
|
make?: Maybe<Scalars["String"]>;
|
|
1133
1129
|
/** Car model name */
|
|
1134
1130
|
model?: Maybe<Scalars["String"]>;
|
|
1135
1131
|
/** Version, edition or submodel of car */
|
|
1136
1132
|
version?: Maybe<Scalars["String"]>;
|
|
1133
|
+
/** Another submodel level of car */
|
|
1134
|
+
edition?: Maybe<Scalars["String"]>;
|
|
1135
|
+
/** Car model version. Added by Chargetrip as an alternative for when a car manufacturer does not provide a version name, or uses the same version name across all trims or consecutive years */
|
|
1136
|
+
chargetrip_version?: Maybe<Scalars["String"]>;
|
|
1137
1137
|
};
|
|
1138
1138
|
|
|
1139
1139
|
export type CarPremiumPerformance = {
|
|
@@ -1157,40 +1157,42 @@ export type CarPremiumPrice = {
|
|
|
1157
1157
|
};
|
|
1158
1158
|
|
|
1159
1159
|
export type CarPremiumPriceValue = {
|
|
1160
|
+
/** Starting price for local market */
|
|
1161
|
+
value?: Maybe<Scalars["Int"]>;
|
|
1160
1162
|
/** Currency name for local market */
|
|
1161
1163
|
currency?: Maybe<Scalars["String"]>;
|
|
1164
|
+
/** Indicates if price value is based on estimates */
|
|
1165
|
+
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1162
1166
|
/**
|
|
1163
1167
|
* Indicates if price value is based on estimates
|
|
1164
1168
|
* @deprecated In favor of is_estimated
|
|
1165
1169
|
*/
|
|
1166
1170
|
estimated?: Maybe<Scalars["Boolean"]>;
|
|
1167
|
-
/** Indicates if price value is based on estimates */
|
|
1168
|
-
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1169
|
-
/** Starting price for local market */
|
|
1170
|
-
value?: Maybe<Scalars["Int"]>;
|
|
1171
1171
|
};
|
|
1172
1172
|
|
|
1173
1173
|
export type CarPremiumPriceValueWithGrant = {
|
|
1174
|
+
/** Starting price for local market */
|
|
1175
|
+
value?: Maybe<Scalars["Int"]>;
|
|
1174
1176
|
/** Currency name for local market */
|
|
1175
1177
|
currency?: Maybe<Scalars["String"]>;
|
|
1178
|
+
/** Indicates if price value is based on estimates */
|
|
1179
|
+
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1180
|
+
/** Grant is applied to value */
|
|
1181
|
+
grant_applied?: Maybe<Scalars["Int"]>;
|
|
1176
1182
|
/**
|
|
1177
1183
|
* Indicates if price value is based on estimates
|
|
1178
1184
|
* @deprecated In favor of is_estimated
|
|
1179
1185
|
*/
|
|
1180
1186
|
estimated?: Maybe<Scalars["Boolean"]>;
|
|
1181
|
-
/** Grant is applied to value */
|
|
1182
|
-
grant_applied?: Maybe<Scalars["Int"]>;
|
|
1183
|
-
/** Indicates if price value is based on estimates */
|
|
1184
|
-
is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1185
|
-
/** Starting price for local market */
|
|
1186
|
-
value?: Maybe<Scalars["Int"]>;
|
|
1187
1187
|
};
|
|
1188
1188
|
|
|
1189
1189
|
export type CarPremiumRange = {
|
|
1190
|
-
/**
|
|
1191
|
-
|
|
1192
|
-
/**
|
|
1193
|
-
|
|
1190
|
+
/** Rated range in WLTP combined cycle (NULL if not WLTP rated) in km */
|
|
1191
|
+
wltp?: Maybe<Scalars["Int"]>;
|
|
1192
|
+
/** Indicates if WLTP range is estimated (NULL if not WLTP rated) */
|
|
1193
|
+
wltp_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1194
|
+
/** Rated range in WLTP (TEH/least efficient trim) combined cycle (NULL if not WLTP rated) */
|
|
1195
|
+
wltp_teh?: Maybe<Scalars["Int"]>;
|
|
1194
1196
|
/** Rated range in NEDC combined cycle (NULL if not NEDC rated) in km */
|
|
1195
1197
|
nedc?: Maybe<Scalars["Int"]>;
|
|
1196
1198
|
/** Indicates if NEDC range is estimated (NULL if not NEDC rated) */
|
|
@@ -1199,36 +1201,34 @@ export type CarPremiumRange = {
|
|
|
1199
1201
|
real?: Maybe<Scalars["Int"]>;
|
|
1200
1202
|
/** Indicates if real is estimated */
|
|
1201
1203
|
real_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1202
|
-
/** Rated range in WLTP combined cycle (NULL if not WLTP rated) in km */
|
|
1203
|
-
wltp?: Maybe<Scalars["Int"]>;
|
|
1204
|
-
/** Indicates if WLTP range is estimated (NULL if not WLTP rated) */
|
|
1205
|
-
wltp_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1206
|
-
/** Rated range in WLTP (TEH/least efficient trim) combined cycle (NULL if not WLTP rated) */
|
|
1207
|
-
wltp_teh?: Maybe<Scalars["Int"]>;
|
|
1208
1204
|
/** Worst conditions are based on -10°C and use of heating */
|
|
1209
1205
|
worst?: Maybe<CarPremiumRangeValue>;
|
|
1206
|
+
/** Best conditions are based on 23°C and no use of A/C */
|
|
1207
|
+
best?: Maybe<CarPremiumRangeValue>;
|
|
1208
|
+
/** Is an index value of what we consider to be the real-world range. (Comparable to Range_Real from EV Database.) It is essentially a normalized range to display on the front-end. */
|
|
1209
|
+
chargetrip_range?: Maybe<ChargetripRange>;
|
|
1210
1210
|
};
|
|
1211
1211
|
|
|
1212
1212
|
export type CarPremiumRangeValue = {
|
|
1213
|
+
/** Estimated value on highway or express roads */
|
|
1214
|
+
highway?: Maybe<Scalars["Int"]>;
|
|
1213
1215
|
/** Estimated value on city roads */
|
|
1214
1216
|
city?: Maybe<Scalars["Int"]>;
|
|
1215
1217
|
/** Estimated combined value */
|
|
1216
1218
|
combined?: Maybe<Scalars["Int"]>;
|
|
1217
|
-
/** Estimated value on highway or express roads */
|
|
1218
|
-
highway?: Maybe<Scalars["Int"]>;
|
|
1219
1219
|
};
|
|
1220
1220
|
|
|
1221
1221
|
export type CarPremiumRouting = {
|
|
1222
|
-
/** Extra consumption model */
|
|
1223
|
-
consumption?: Maybe<CarPremiumRoutingConsumption>;
|
|
1224
|
-
/** Drag coefficient */
|
|
1225
|
-
drag_coefficient?: Maybe<Scalars["Float"]>;
|
|
1226
1222
|
/** Cars that support fast charging have a minimum charging speed of 43 kWh */
|
|
1227
1223
|
fast_charging_support?: Maybe<Scalars["Boolean"]>;
|
|
1228
|
-
/**
|
|
1229
|
-
|
|
1224
|
+
/** Drag coefficient */
|
|
1225
|
+
drag_coefficient?: Maybe<Scalars["Float"]>;
|
|
1230
1226
|
/** Tire pressure recommended by manufacturer */
|
|
1231
1227
|
tire_pressure?: Maybe<Scalars["Float"]>;
|
|
1228
|
+
/** Extra consumption model */
|
|
1229
|
+
consumption?: Maybe<CarPremiumRoutingConsumption>;
|
|
1230
|
+
/** Amount of petrol that an equivalent petrol car would consume in l/100 km */
|
|
1231
|
+
petrol_consumption?: Maybe<Scalars["Float"]>;
|
|
1232
1232
|
};
|
|
1233
1233
|
|
|
1234
1234
|
export type CarPremiumRoutingConsumption = {
|
|
@@ -1248,25 +1248,25 @@ export type CarPremiumRoutingConsumptionValue = {
|
|
|
1248
1248
|
};
|
|
1249
1249
|
|
|
1250
1250
|
export type CarPremiumSafety = {
|
|
1251
|
-
/** EuroNCAP results */
|
|
1252
|
-
euro_ncap?: Maybe<CarPremiumSafetyEuroNcap>;
|
|
1253
1251
|
/** Number of seats equipped with ISOFIX */
|
|
1254
1252
|
isofix_seats?: Maybe<Scalars["Int"]>;
|
|
1253
|
+
/** EuroNCAP results */
|
|
1254
|
+
euro_ncap?: Maybe<CarPremiumSafetyEuroNcap>;
|
|
1255
1255
|
};
|
|
1256
1256
|
|
|
1257
1257
|
export type CarPremiumSafetyEuroNcap = {
|
|
1258
|
+
/** EuroNCAP rating (out of 5 stars) */
|
|
1259
|
+
rating?: Maybe<Scalars["Int"]>;
|
|
1260
|
+
/** EuroNCAP year of rating */
|
|
1261
|
+
year?: Maybe<Scalars["Int"]>;
|
|
1258
1262
|
/** EuroNCAP rating of adult protection (out of 100%) */
|
|
1259
1263
|
adult?: Maybe<Scalars["Int"]>;
|
|
1260
1264
|
/** EuroNCAP rating of child protection (out of 100%) */
|
|
1261
1265
|
child?: Maybe<Scalars["Int"]>;
|
|
1262
|
-
/** EuroNCAP rating (out of 5 stars) */
|
|
1263
|
-
rating?: Maybe<Scalars["Int"]>;
|
|
1264
|
-
/** EuroNCAP rating of safety assists (out of 100%) */
|
|
1265
|
-
sa?: Maybe<Scalars["Int"]>;
|
|
1266
1266
|
/** EuroNCAP rating of vulnerable road users (out of 100%) */
|
|
1267
1267
|
vru?: Maybe<Scalars["Int"]>;
|
|
1268
|
-
/** EuroNCAP
|
|
1269
|
-
|
|
1268
|
+
/** EuroNCAP rating of safety assists (out of 100%) */
|
|
1269
|
+
sa?: Maybe<Scalars["Int"]>;
|
|
1270
1270
|
};
|
|
1271
1271
|
|
|
1272
1272
|
/** Propulsion */
|
|
@@ -1280,27 +1280,27 @@ export enum CarPropulsion {
|
|
|
1280
1280
|
}
|
|
1281
1281
|
|
|
1282
1282
|
export type CarRange = {
|
|
1283
|
-
/** Best conditions are based on 23°C and no use of A/C */
|
|
1284
|
-
best?: Maybe<CarRangeValue>;
|
|
1285
|
-
/** Chargetrip's custom real world range provides a carefully calculated display range for all EV models. This is based on our own research and driving data */
|
|
1286
|
-
chargetrip_range?: Maybe<ChargetripRange>;
|
|
1287
1283
|
/** Index range in EV Database RealRange model in km */
|
|
1288
1284
|
real?: Maybe<Scalars["Int"]>;
|
|
1289
1285
|
/** Indicates if real is estimated */
|
|
1290
1286
|
real_is_estimated?: Maybe<Scalars["Boolean"]>;
|
|
1291
|
-
/** @deprecated You will receive null values */
|
|
1292
|
-
wltp?: Maybe<Scalars["Float"]>;
|
|
1293
1287
|
/** Worst conditions are based on -10°C and use of heating */
|
|
1294
1288
|
worst?: Maybe<CarRangeValue>;
|
|
1289
|
+
/** Best conditions are based on 23°C and no use of A/C */
|
|
1290
|
+
best?: Maybe<CarRangeValue>;
|
|
1291
|
+
/** Chargetrip's custom real world range provides a carefully calculated display range for all EV models. This is based on our own research and driving data */
|
|
1292
|
+
chargetrip_range?: Maybe<ChargetripRange>;
|
|
1293
|
+
/** @deprecated You will receive null values */
|
|
1294
|
+
wltp?: Maybe<Scalars["Float"]>;
|
|
1295
1295
|
};
|
|
1296
1296
|
|
|
1297
1297
|
export type CarRangeValue = {
|
|
1298
|
+
/** Estimated value on the highway or express roads */
|
|
1299
|
+
highway?: Maybe<Scalars["Int"]>;
|
|
1298
1300
|
/** Estimated value on the cities road */
|
|
1299
1301
|
city?: Maybe<Scalars["Int"]>;
|
|
1300
1302
|
/** Estimated combined value */
|
|
1301
1303
|
combined?: Maybe<Scalars["Int"]>;
|
|
1302
|
-
/** Estimated value on the highway or express roads */
|
|
1303
|
-
highway?: Maybe<Scalars["Int"]>;
|
|
1304
1304
|
};
|
|
1305
1305
|
|
|
1306
1306
|
export type CarRouting = {
|
|
@@ -1312,12 +1312,12 @@ export type CarRouting = {
|
|
|
1312
1312
|
export enum CarStatus {
|
|
1313
1313
|
/** Was just imported */
|
|
1314
1314
|
NEW = "new",
|
|
1315
|
+
/** Is being reviewed by a human operator */
|
|
1316
|
+
REVIEW = "review",
|
|
1315
1317
|
/** Is public and can be used by a customer */
|
|
1316
1318
|
PUBLIC = "public",
|
|
1317
1319
|
/** Is removed and can not be used */
|
|
1318
|
-
REMOVED = "removed"
|
|
1319
|
-
/** Is being reviewed by a human operator */
|
|
1320
|
-
REVIEW = "review"
|
|
1320
|
+
REMOVED = "removed"
|
|
1321
1321
|
}
|
|
1322
1322
|
|
|
1323
1323
|
export type CarVideo = {
|
|
@@ -1329,22 +1329,22 @@ export type CarVideo = {
|
|
|
1329
1329
|
|
|
1330
1330
|
/** Charging mode used at charging stations */
|
|
1331
1331
|
export enum ChargeMode {
|
|
1332
|
-
/** Charge to the maximum capacity at every charging stop. The default maximum charging capacity is 80% */
|
|
1333
|
-
ALWAYS_TO_MAX_CHARGE = "ALWAYS_TO_MAX_CHARGE",
|
|
1334
1332
|
/** Optimizes the charging time at each station, in order to decrease the total travel time. You will only charge up until the SOC you need in order to reach the next stop */
|
|
1335
|
-
OPTIMIZE_TRAVEL_TIME = "OPTIMIZE_TRAVEL_TIME"
|
|
1333
|
+
OPTIMIZE_TRAVEL_TIME = "OPTIMIZE_TRAVEL_TIME",
|
|
1334
|
+
/** Charge to the maximum capacity at every charging stop. The default maximum charging capacity is 80% */
|
|
1335
|
+
ALWAYS_TO_MAX_CHARGE = "ALWAYS_TO_MAX_CHARGE"
|
|
1336
1336
|
}
|
|
1337
1337
|
|
|
1338
1338
|
/** A groupped representation of EVSEs */
|
|
1339
1339
|
export type Charger = {
|
|
1340
|
+
/** Type of charger */
|
|
1341
|
+
standard?: Maybe<ConnectorType>;
|
|
1340
1342
|
/** Power of a charger */
|
|
1341
1343
|
power?: Maybe<Scalars["Float"]>;
|
|
1342
1344
|
/** Price of a charger */
|
|
1343
1345
|
price?: Maybe<Scalars["String"]>;
|
|
1344
1346
|
/** Charging speed */
|
|
1345
1347
|
speed?: Maybe<StationSpeedType>;
|
|
1346
|
-
/** Type of charger */
|
|
1347
|
-
standard?: Maybe<ConnectorType>;
|
|
1348
1348
|
/** Statuses of all the EVSEs grouped in a charger */
|
|
1349
1349
|
status?: Maybe<ChargerStatuses>;
|
|
1350
1350
|
/** Total number of EVSEs grouped in a charger */
|
|
@@ -1352,34 +1352,34 @@ export type Charger = {
|
|
|
1352
1352
|
};
|
|
1353
1353
|
|
|
1354
1354
|
export enum ChargerStatus {
|
|
1355
|
-
/** The charger is occupied/busy */
|
|
1356
|
-
BUSY = "busy",
|
|
1357
|
-
/** The charger has an error */
|
|
1358
|
-
ERROR = "error",
|
|
1359
1355
|
/** The charger is free */
|
|
1360
1356
|
FREE = "free",
|
|
1357
|
+
/** The charger is occupied/busy */
|
|
1358
|
+
BUSY = "busy",
|
|
1361
1359
|
/** The charger is unknown */
|
|
1362
|
-
UNKNOWN = "unknown"
|
|
1360
|
+
UNKNOWN = "unknown",
|
|
1361
|
+
/** The charger has an error */
|
|
1362
|
+
ERROR = "error"
|
|
1363
1363
|
}
|
|
1364
1364
|
|
|
1365
1365
|
/** Groupping by status of the chargers */
|
|
1366
1366
|
export type ChargerStatuses = {
|
|
1367
|
-
/** How many are busy */
|
|
1368
|
-
busy?: Maybe<Scalars["Int"]>;
|
|
1369
|
-
/** How many are not available */
|
|
1370
|
-
error?: Maybe<Scalars["Int"]>;
|
|
1371
1367
|
/** How many are free */
|
|
1372
1368
|
free?: Maybe<Scalars["Int"]>;
|
|
1369
|
+
/** How many are busy */
|
|
1370
|
+
busy?: Maybe<Scalars["Int"]>;
|
|
1373
1371
|
/** How many are unknown */
|
|
1374
1372
|
unknown?: Maybe<Scalars["Int"]>;
|
|
1373
|
+
/** How many are not available */
|
|
1374
|
+
error?: Maybe<Scalars["Int"]>;
|
|
1375
1375
|
};
|
|
1376
1376
|
|
|
1377
1377
|
/** Chargetrip's custom real world range provides a carefully calculated display range for all EV models. This is based on our own research and driving data */
|
|
1378
1378
|
export type ChargetripRange = {
|
|
1379
|
-
/** Best conditions are based on 23°C and no use of A/C */
|
|
1380
|
-
best?: Maybe<Scalars["Float"]>;
|
|
1381
1379
|
/** Worst conditions are based on -10°C and use of heating */
|
|
1382
1380
|
worst?: Maybe<Scalars["Float"]>;
|
|
1381
|
+
/** Best conditions are based on 23°C and no use of A/C */
|
|
1382
|
+
best?: Maybe<Scalars["Float"]>;
|
|
1383
1383
|
};
|
|
1384
1384
|
|
|
1385
1385
|
export type ChargingBehaviour = {
|
|
@@ -1390,18 +1390,18 @@ export type ChargingBehaviour = {
|
|
|
1390
1390
|
};
|
|
1391
1391
|
|
|
1392
1392
|
export enum ChargingBehaviourCode {
|
|
1393
|
+
/** Mainly morning charging, and some mixed afternoon and evening charging */
|
|
1394
|
+
URBAN_CHARGING = "URBAN_CHARGING",
|
|
1393
1395
|
/** Mainly fast charging, with some morning and afternoon charging */
|
|
1394
1396
|
FAST_CHARGING = "FAST_CHARGING",
|
|
1395
1397
|
/** Mixed behaviour between morning, afternoon, evening, overnight, and noise charging */
|
|
1396
1398
|
MIXED_CHARGING = "MIXED_CHARGING",
|
|
1397
1399
|
/** Mainly noise charging */
|
|
1398
1400
|
NOISE_CHARGING = "NOISE_CHARGING",
|
|
1399
|
-
/** Mainly morning charging, with some afternoon charging */
|
|
1400
|
-
OFFICE_CHARGING = "OFFICE_CHARGING",
|
|
1401
1401
|
/** Mainly overnight charging */
|
|
1402
1402
|
OVERNIGHT_CHARGING = "OVERNIGHT_CHARGING",
|
|
1403
|
-
/** Mainly morning charging,
|
|
1404
|
-
|
|
1403
|
+
/** Mainly morning charging, with some afternoon charging */
|
|
1404
|
+
OFFICE_CHARGING = "OFFICE_CHARGING"
|
|
1405
1405
|
}
|
|
1406
1406
|
|
|
1407
1407
|
export type Connect = {
|
|
@@ -1420,14 +1420,16 @@ export enum ConnectProvider {
|
|
|
1420
1420
|
|
|
1421
1421
|
/** Connector data which extends OCPI Connector */
|
|
1422
1422
|
export type Connector = {
|
|
1423
|
-
/** 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 */
|
|
1424
|
-
custom_properties?: Maybe<ConnectorCustomProperties>;
|
|
1425
|
-
/** Format (socket/cable) of an installed connector. */
|
|
1426
|
-
format?: Maybe<OCPIConnectorFormat>;
|
|
1427
1423
|
/** Identifier of a connector within an EVSE. Two connectors may have the same ID as long as they do not belong to the same EVSE object. */
|
|
1428
1424
|
id?: Maybe<Scalars["String"]>;
|
|
1429
|
-
/**
|
|
1430
|
-
|
|
1425
|
+
/** Standard of an installed connector. */
|
|
1426
|
+
standard?: Maybe<ConnectorType>;
|
|
1427
|
+
/** Format (socket/cable) of an installed connector. */
|
|
1428
|
+
format?: Maybe<OCPIConnectorFormat>;
|
|
1429
|
+
/** Type of power of an installed connector. */
|
|
1430
|
+
power_type?: Maybe<OCPIPowerType>;
|
|
1431
|
+
/** Maximum voltage of an connector (line to neutral for AC_3_PHASE), in volt [V]. For example: DC Chargers might vary the voltage during charging when battery almost full. */
|
|
1432
|
+
max_voltage?: Maybe<Scalars["Int"]>;
|
|
1431
1433
|
/** Maximum amperage of a connector, in ampere [A]. */
|
|
1432
1434
|
max_amperage?: Maybe<Scalars["Int"]>;
|
|
1433
1435
|
/**
|
|
@@ -1436,23 +1438,8 @@ export type Connector = {
|
|
|
1436
1438
|
* For AC Charge Points, the amount of phases used can also have influence on the maximum power.
|
|
1437
1439
|
*/
|
|
1438
1440
|
max_electric_power?: Maybe<Scalars["Int"]>;
|
|
1439
|
-
/** Maximum voltage of an connector (line to neutral for AC_3_PHASE), in volt [V]. For example: DC Chargers might vary the voltage during charging when battery almost full. */
|
|
1440
|
-
max_voltage?: Maybe<Scalars["Int"]>;
|
|
1441
1441
|
/** Maximum electric power in kW */
|
|
1442
1442
|
power?: Maybe<Scalars["Float"]>;
|
|
1443
|
-
/** Type of power of an installed connector. */
|
|
1444
|
-
power_type?: Maybe<OCPIPowerType>;
|
|
1445
|
-
/**
|
|
1446
|
-
* Charging prices
|
|
1447
|
-
* @deprecated In favor of custom_properties.pricing
|
|
1448
|
-
*/
|
|
1449
|
-
pricing?: Maybe<Pricing>;
|
|
1450
|
-
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1451
|
-
properties?: Maybe<Scalars["JSON"]>;
|
|
1452
|
-
/** Standard of an installed connector. */
|
|
1453
|
-
standard?: Maybe<ConnectorType>;
|
|
1454
|
-
/** List of valid charging tariffs */
|
|
1455
|
-
tariff?: Maybe<Array<Maybe<OCPITariff>>>;
|
|
1456
1443
|
/**
|
|
1457
1444
|
* Identifiers of the currently valid charging tariffs. Multiple tariffs are possible, but only one of each Tariff.type can be active at the same time. Tariffs with the same type are only allowed, if they are not active at the same time: start_date_time and end_date_time period not overlapping.
|
|
1458
1445
|
* When preference-based smart charging is supported, one tariff for every possible ProfileType should be provided. This tells the user about the options they have at this Connector, and what the tariff is for every option.
|
|
@@ -1461,6 +1448,19 @@ export type Connector = {
|
|
|
1461
1448
|
tariff_ids?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
1462
1449
|
/** URL to an operator’s terms and conditions. */
|
|
1463
1450
|
terms_and_conditions?: Maybe<Scalars["String"]>;
|
|
1451
|
+
/** Timestamp when a connector was last updated (or created). */
|
|
1452
|
+
last_updated?: Maybe<Scalars["DateTime"]>;
|
|
1453
|
+
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1454
|
+
properties?: Maybe<Scalars["JSON"]>;
|
|
1455
|
+
/** List of valid charging tariffs */
|
|
1456
|
+
tariff?: Maybe<Array<Maybe<OCPITariff>>>;
|
|
1457
|
+
/**
|
|
1458
|
+
* Charging prices
|
|
1459
|
+
* @deprecated In favor of custom_properties.pricing
|
|
1460
|
+
*/
|
|
1461
|
+
pricing?: Maybe<Pricing>;
|
|
1462
|
+
/** 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 */
|
|
1463
|
+
custom_properties?: Maybe<ConnectorCustomProperties>;
|
|
1464
1464
|
};
|
|
1465
1465
|
|
|
1466
1466
|
export type ConnectorCustomProperties = {
|
|
@@ -1472,8 +1472,6 @@ export type ConnectorCustomProperties = {
|
|
|
1472
1472
|
export enum ConnectorType {
|
|
1473
1473
|
/** The connector type is CHAdeMO, DC */
|
|
1474
1474
|
CHADEMO = "CHADEMO",
|
|
1475
|
-
/** The ChaoJi connector. The new generation charging connector, harmonized between CHAdeMO and GB/T. DC. */
|
|
1476
|
-
CHAOJI = "CHAOJI",
|
|
1477
1475
|
/** Standard/domestic household, type "A", NEMA 1-15, 2 pins */
|
|
1478
1476
|
DOMESTIC_A = "DOMESTIC_A",
|
|
1479
1477
|
/** Standard/domestic household, type "B", NEMA 5-15, 3 pins */
|
|
@@ -1504,8 +1502,6 @@ export enum ConnectorType {
|
|
|
1504
1502
|
DOMESTIC_N = "DOMESTIC_N",
|
|
1505
1503
|
/** Standard/Domestic household, type "O", TIS 166-2549, 3 pins */
|
|
1506
1504
|
DOMESTIC_O = "DOMESTIC_O",
|
|
1507
|
-
/** The connector type is GB_T (Chinese standard), DC */
|
|
1508
|
-
GB_T = "GB_T",
|
|
1509
1505
|
/** IEC 60309-2 Industrial connector single phase 16 amperes (usually blue) */
|
|
1510
1506
|
IEC_60309_2_SINGLE_16 = "IEC_60309_2_single_16",
|
|
1511
1507
|
/** IEC 60309-2 Industrial connector three phase 16 amperes (usually red) */
|
|
@@ -1526,6 +1522,18 @@ export enum ConnectorType {
|
|
|
1526
1522
|
IEC_62196_T3A = "IEC_62196_T3A",
|
|
1527
1523
|
/** IEC 62196 Type 3C "Scame" */
|
|
1528
1524
|
IEC_62196_T3C = "IEC_62196_T3C",
|
|
1525
|
+
/** On-board bottom-up-pantograph typically for bus charging */
|
|
1526
|
+
PANTOGRAPH_BOTTOM_UP = "PANTOGRAPH_BOTTOM_UP",
|
|
1527
|
+
/** Off-board top-down-pantograph typically for bus charging */
|
|
1528
|
+
PANTOGRAPH_TOP_DOWN = "PANTOGRAPH_TOP_DOWN",
|
|
1529
|
+
/** Tesla connector "Roadster"-type (round, 4 pins) */
|
|
1530
|
+
TESLA_R = "TESLA_R",
|
|
1531
|
+
/** Tesla connector "Model-S"-type (oval, 5 pins) */
|
|
1532
|
+
TESLA_S = "TESLA_S",
|
|
1533
|
+
/** The connector type is GB_T (Chinese standard), DC */
|
|
1534
|
+
GB_T = "GB_T",
|
|
1535
|
+
/** The ChaoJi connector. The new generation charging connector, harmonized between CHAdeMO and GB/T. DC. */
|
|
1536
|
+
CHAOJI = "CHAOJI",
|
|
1529
1537
|
/** The connector type is NEMA 5-20, 3 pins */
|
|
1530
1538
|
NEMA_5_20 = "NEMA_5_20",
|
|
1531
1539
|
/** The connector type is NEMA 6-30, 3 pins */
|
|
@@ -1539,31 +1547,23 @@ export enum ConnectorType {
|
|
|
1539
1547
|
/** The connector type is NEMA 14-30, 3 pins, rating of 30 A */
|
|
1540
1548
|
NEMA_14_30 = "NEMA_14_30",
|
|
1541
1549
|
/** The connector type is NEMA 14-50, 3 pins, rating of 50 A */
|
|
1542
|
-
NEMA_14_50 = "NEMA_14_50"
|
|
1543
|
-
/** On-board bottom-up-pantograph typically for bus charging */
|
|
1544
|
-
PANTOGRAPH_BOTTOM_UP = "PANTOGRAPH_BOTTOM_UP",
|
|
1545
|
-
/** Off-board top-down-pantograph typically for bus charging */
|
|
1546
|
-
PANTOGRAPH_TOP_DOWN = "PANTOGRAPH_TOP_DOWN",
|
|
1547
|
-
/** Tesla connector "Roadster"-type (round, 4 pins) */
|
|
1548
|
-
TESLA_R = "TESLA_R",
|
|
1549
|
-
/** Tesla connector "Model-S"-type (oval, 5 pins) */
|
|
1550
|
-
TESLA_S = "TESLA_S"
|
|
1550
|
+
NEMA_14_50 = "NEMA_14_50"
|
|
1551
1551
|
}
|
|
1552
1552
|
|
|
1553
1553
|
/** The complete contact information */
|
|
1554
1554
|
export type Contact = {
|
|
1555
|
+
/** The phone number in international format */
|
|
1556
|
+
phone?: Maybe<Scalars["String"]>;
|
|
1555
1557
|
/** The email address */
|
|
1556
1558
|
email?: Maybe<Scalars["String"]>;
|
|
1559
|
+
/** The absolute URL of the website */
|
|
1560
|
+
website?: Maybe<Scalars["String"]>;
|
|
1557
1561
|
/** The absolute URL of the facebook profile page */
|
|
1558
1562
|
facebook?: Maybe<Scalars["String"]>;
|
|
1559
|
-
/** The phone number in international format */
|
|
1560
|
-
phone?: Maybe<Scalars["String"]>;
|
|
1561
|
-
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1562
|
-
properties?: Maybe<Scalars["JSON"]>;
|
|
1563
1563
|
/** The absolute URL of the twitter profile page */
|
|
1564
1564
|
twitter?: Maybe<Scalars["String"]>;
|
|
1565
|
-
/**
|
|
1566
|
-
|
|
1565
|
+
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1566
|
+
properties?: Maybe<Scalars["JSON"]>;
|
|
1567
1567
|
};
|
|
1568
1568
|
|
|
1569
1569
|
/** ISO-3166 alpha-2 country codes */
|
|
@@ -1824,71 +1824,71 @@ export enum CountryCodeAlpha2 {
|
|
|
1824
1824
|
|
|
1825
1825
|
/** EVSE data which extends OCPI EVSE */
|
|
1826
1826
|
export type EVSE = {
|
|
1827
|
+
/**
|
|
1828
|
+
* Uniquely identifies an EVSE within the CPOs platform (and suboperator platforms). For example a database ID or the actual "EVSE ID". This field can never be changed, modified or renamed. This is the 'technical' identification of the EVSE, not to be used as 'human readable' identification, use the field evse_id for that.
|
|
1829
|
+
* This field is named uid instead of id, because id could be confused with evse_id which is an eMI3 defined field.
|
|
1830
|
+
*/
|
|
1831
|
+
uid?: Maybe<Scalars["String"]>;
|
|
1832
|
+
/** Compliant with the following specification for EVSE ID from "eMI3 standard version V1.0" (http://emi3group.com/documents-links/) "Part 2: business objects." Optional because: if an evse_id is to be re-used in the real world, the evse_id can be removed from an EVSE object if the status is set to REMOVED. */
|
|
1833
|
+
evse_id?: Maybe<Scalars["String"]>;
|
|
1834
|
+
/** Indicates the current status of an EVSE. */
|
|
1835
|
+
status?: Maybe<OCPIStatus>;
|
|
1836
|
+
/** Indicates a planned status update of a nEVSE. */
|
|
1837
|
+
status_schedule?: Maybe<Array<Maybe<OCPIStatusSchedule>>>;
|
|
1827
1838
|
/** List of functionalities that an EVSE is capable of. */
|
|
1828
1839
|
capabilities?: Maybe<Array<Maybe<OCPICapability>>>;
|
|
1829
1840
|
/** List of available connectors on an EVSE. */
|
|
1830
1841
|
connectors?: Maybe<Array<Maybe<Connector>>>;
|
|
1831
|
-
/** Coordinates of a EVSE. */
|
|
1832
|
-
coordinates?: Maybe<OCPIGeoLocation>;
|
|
1833
|
-
/** Compliant with the following specification for EVSE ID from "eMI3 standard version V1.0" (http://emi3group.com/documents-links/) "Part 2: business objects." Optional because: if an evse_id is to be re-used in the real world, the evse_id can be removed from an EVSE object if the status is set to REMOVED. */
|
|
1834
|
-
evse_id?: Maybe<Scalars["String"]>;
|
|
1835
1842
|
/** Level on which a Charge Point is located (in garage buildings) in the locally displayed numbering scheme. */
|
|
1836
1843
|
floor_level?: Maybe<Scalars["String"]>;
|
|
1844
|
+
/** Coordinates of a EVSE. */
|
|
1845
|
+
coordinates?: Maybe<OCPIGeoLocation>;
|
|
1846
|
+
/** A number/string printed on the outside of an EVSE for visual identification. */
|
|
1847
|
+
physical_reference?: Maybe<Scalars["String"]>;
|
|
1848
|
+
/** Restrictions that apply to a parking spot. */
|
|
1849
|
+
parking_restrictions?: Maybe<Array<Maybe<OCPIParkingRestriction>>>;
|
|
1837
1850
|
/** Links to images related to an EVSE such as photos or logos. */
|
|
1838
1851
|
images?: Maybe<Array<Maybe<OCPIImage>>>;
|
|
1839
1852
|
/** Timestamp when this EVSE or one of its Connectors was last updated (or created). */
|
|
1840
1853
|
last_updated?: Maybe<Scalars["DateTime"]>;
|
|
1841
1854
|
/** Indicates if parking is free or paid. */
|
|
1842
1855
|
parking_cost?: Maybe<ParkingCost>;
|
|
1843
|
-
/** Restrictions that apply to a parking spot. */
|
|
1844
|
-
parking_restrictions?: Maybe<Array<Maybe<OCPIParkingRestriction>>>;
|
|
1845
|
-
/** A number/string printed on the outside of an EVSE for visual identification. */
|
|
1846
|
-
physical_reference?: Maybe<Scalars["String"]>;
|
|
1847
1856
|
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1848
1857
|
properties?: Maybe<Scalars["JSON"]>;
|
|
1849
|
-
/** Indicates the current status of an EVSE. */
|
|
1850
|
-
status?: Maybe<OCPIStatus>;
|
|
1851
|
-
/** Indicates a planned status update of a nEVSE. */
|
|
1852
|
-
status_schedule?: Maybe<Array<Maybe<OCPIStatusSchedule>>>;
|
|
1853
|
-
/**
|
|
1854
|
-
* Uniquely identifies an EVSE within the CPOs platform (and suboperator platforms). For example a database ID or the actual "EVSE ID". This field can never be changed, modified or renamed. This is the 'technical' identification of the EVSE, not to be used as 'human readable' identification, use the field evse_id for that.
|
|
1855
|
-
* This field is named uid instead of id, because id could be confused with evse_id which is an eMI3 defined field.
|
|
1856
|
-
*/
|
|
1857
|
-
uid?: Maybe<Scalars["String"]>;
|
|
1858
1858
|
};
|
|
1859
1859
|
|
|
1860
1860
|
/** A GeoJSON Feature<Point> */
|
|
1861
1861
|
export type FeaturePoint = {
|
|
1862
|
-
/** Geometry of the feature */
|
|
1863
|
-
geometry: Point;
|
|
1864
1862
|
/** Feature ID */
|
|
1865
1863
|
id?: Maybe<Scalars["String"]>;
|
|
1866
|
-
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1867
|
-
properties?: Maybe<Scalars["JSON"]>;
|
|
1868
1864
|
/** Feature type */
|
|
1869
1865
|
type: FeatureType;
|
|
1866
|
+
/** Geometry of the feature */
|
|
1867
|
+
geometry: Point;
|
|
1868
|
+
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1869
|
+
properties?: Maybe<Scalars["JSON"]>;
|
|
1870
1870
|
};
|
|
1871
1871
|
|
|
1872
1872
|
/** A GeoJSON Feature<Point> input */
|
|
1873
1873
|
export type FeaturePointInput = {
|
|
1874
|
-
/** Geometry of the feature */
|
|
1875
|
-
geometry: PointInput;
|
|
1876
1874
|
/** The feature ID */
|
|
1877
1875
|
id?: Maybe<Scalars["String"]>;
|
|
1878
|
-
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1879
|
-
properties?: Maybe<Scalars["JSON"]>;
|
|
1880
1876
|
/** Feature type */
|
|
1881
1877
|
type: FeatureType;
|
|
1878
|
+
/** Geometry of the feature */
|
|
1879
|
+
geometry: PointInput;
|
|
1880
|
+
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
1881
|
+
properties?: Maybe<Scalars["JSON"]>;
|
|
1882
1882
|
};
|
|
1883
1883
|
|
|
1884
1884
|
/** A GeoJSON Feature<Point> input */
|
|
1885
1885
|
export type FeaturePointPolygonInput = {
|
|
1886
|
+
/** Feature type */
|
|
1887
|
+
type: FeatureType;
|
|
1886
1888
|
/** Geometry of the feature */
|
|
1887
1889
|
geometry: PointInput;
|
|
1888
1890
|
/** Optional object where you can store custom data you need in your application. */
|
|
1889
1891
|
properties?: Maybe<FeaturePointPolygonPropertiesInput>;
|
|
1890
|
-
/** Feature type */
|
|
1891
|
-
type: FeatureType;
|
|
1892
1892
|
};
|
|
1893
1893
|
|
|
1894
1894
|
/** Properties for Feature<Point> input */
|
|
@@ -1905,22 +1905,22 @@ export type FeaturePointPolygonPropertiesInput = {
|
|
|
1905
1905
|
|
|
1906
1906
|
/** A GeoJSON Feature<Polygon> */
|
|
1907
1907
|
export type FeaturePolygon = {
|
|
1908
|
+
/** Feature type */
|
|
1909
|
+
type: FeatureType;
|
|
1908
1910
|
/** Geometry of the feature */
|
|
1909
1911
|
geometry: Polygon;
|
|
1910
1912
|
/** Properties of the Polygon Feature */
|
|
1911
1913
|
properties?: Maybe<PolygonProperties>;
|
|
1912
|
-
/** Feature type */
|
|
1913
|
-
type: FeatureType;
|
|
1914
1914
|
};
|
|
1915
1915
|
|
|
1916
1916
|
/** A GeoJSON Feature<Point> */
|
|
1917
1917
|
export type FeaturePolygonPoint = {
|
|
1918
|
+
/** Feature type */
|
|
1919
|
+
type: FeatureType;
|
|
1918
1920
|
/** Geometry of the feature */
|
|
1919
1921
|
geometry: Point;
|
|
1920
1922
|
/** Optional object where you can store custom data you need in your application. */
|
|
1921
1923
|
properties?: Maybe<Scalars["JSON"]>;
|
|
1922
|
-
/** Feature type */
|
|
1923
|
-
type: FeatureType;
|
|
1924
1924
|
};
|
|
1925
1925
|
|
|
1926
1926
|
/** GeoJSON Feature type */
|
|
@@ -1939,53 +1939,53 @@ export enum InstructionsFormat {
|
|
|
1939
1939
|
export type Isoline = {
|
|
1940
1940
|
/** Isoline id */
|
|
1941
1941
|
id: Scalars["ID"];
|
|
1942
|
+
/** Isoline status */
|
|
1943
|
+
status: IsolineStatus;
|
|
1944
|
+
/** Shape of the isoline consisting in a list of polygons */
|
|
1945
|
+
polygons?: Maybe<Array<Maybe<FeaturePolygon>>>;
|
|
1942
1946
|
/** Origin point of the request */
|
|
1943
1947
|
origin: FeaturePolygonPoint;
|
|
1948
|
+
/** Vehicle id */
|
|
1949
|
+
vehicle_id: Scalars["ID"];
|
|
1944
1950
|
/** Number of Isolines to be generated representing SoC (default: 1, max: 100) */
|
|
1945
1951
|
polygon_count?: Maybe<Scalars["Int"]>;
|
|
1946
|
-
/** Shape of the isoline consisting in a list of polygons */
|
|
1947
|
-
polygons?: Maybe<Array<Maybe<FeaturePolygon>>>;
|
|
1948
1952
|
/** Season to be taken into account when generating the isoline, defaults to current */
|
|
1949
1953
|
season?: Maybe<RouteSeason>;
|
|
1950
|
-
/** Isoline status */
|
|
1951
|
-
status: IsolineStatus;
|
|
1952
|
-
/** Vehicle id */
|
|
1953
|
-
vehicle_id: Scalars["ID"];
|
|
1954
1954
|
};
|
|
1955
1955
|
|
|
1956
1956
|
export type IsolineInput = {
|
|
1957
|
+
/** Vehicle id */
|
|
1958
|
+
vehicle_id: Scalars["ID"];
|
|
1957
1959
|
/** Origin point of the request */
|
|
1958
1960
|
origin: FeaturePointPolygonInput;
|
|
1959
1961
|
/** Numbers of polygons to be generated (default: 1, max: 100) */
|
|
1960
1962
|
polygon_count?: Maybe<Scalars["Int"]>;
|
|
1961
1963
|
/** Season to be taken into account when generating the isoline, defaults to current */
|
|
1962
1964
|
season?: Maybe<RouteSeason>;
|
|
1963
|
-
/** Vehicle id */
|
|
1964
|
-
vehicle_id: Scalars["ID"];
|
|
1965
1965
|
};
|
|
1966
1966
|
|
|
1967
1967
|
/** Status of the isoline label */
|
|
1968
1968
|
export enum IsolineStatus {
|
|
1969
1969
|
/** Isoline label has been successfully generated */
|
|
1970
1970
|
DONE = "done",
|
|
1971
|
-
/** There was an error while generating the isoline label */
|
|
1972
|
-
ERROR = "error",
|
|
1973
1971
|
/** Isoline label is under processing */
|
|
1974
|
-
PENDING = "pending"
|
|
1972
|
+
PENDING = "pending",
|
|
1973
|
+
/** There was an error while generating the isoline label */
|
|
1974
|
+
ERROR = "error"
|
|
1975
1975
|
}
|
|
1976
1976
|
|
|
1977
1977
|
/** Types of a leg */
|
|
1978
1978
|
export enum LegType {
|
|
1979
|
-
/** This leg ends at the destination, and is the last leg of the route */
|
|
1980
|
-
FINAL = "final",
|
|
1981
1979
|
/** This leg ends at a charging station and the car must recharge */
|
|
1982
1980
|
STATION = "station",
|
|
1983
|
-
/** This leg ends at the destination which is a charging station, and is the last leg of the route */
|
|
1984
|
-
STATIONFINAL = "stationFinal",
|
|
1985
1981
|
/** This leg ends at a via charging station and the car must recharge */
|
|
1986
1982
|
STATIONVIA = "stationVia",
|
|
1987
1983
|
/** This leg ends at a via location */
|
|
1988
|
-
VIA = "via"
|
|
1984
|
+
VIA = "via",
|
|
1985
|
+
/** This leg ends at the destination, and is the last leg of the route */
|
|
1986
|
+
FINAL = "final",
|
|
1987
|
+
/** This leg ends at the destination which is a charging station, and is the last leg of the route */
|
|
1988
|
+
STATIONFINAL = "stationFinal"
|
|
1989
1989
|
}
|
|
1990
1990
|
|
|
1991
1991
|
/** Preferred language for the mapping */
|
|
@@ -2003,85 +2003,85 @@ export enum MappingProvider {
|
|
|
2003
2003
|
}
|
|
2004
2004
|
|
|
2005
2005
|
export type Mutation = {
|
|
2006
|
+
/** [BETA] Generate a set of consumption based Isolines */
|
|
2007
|
+
createIsoline?: Maybe<Scalars["ID"]>;
|
|
2008
|
+
/** [BETA] Start a new navigation session on top of an existing route */
|
|
2009
|
+
startNavigation?: Maybe<Scalars["ID"]>;
|
|
2010
|
+
/** [BETA] Update the navigation session */
|
|
2011
|
+
updateNavigation?: Maybe<Scalars["Void"]>;
|
|
2012
|
+
/** [BETA] Recalculate the current navigation route */
|
|
2013
|
+
recalculateNavigation?: Maybe<Scalars["Void"]>;
|
|
2014
|
+
/** [BETA] End a navigation session */
|
|
2015
|
+
finishNavigation?: Maybe<Scalars["Void"]>;
|
|
2006
2016
|
/**
|
|
2007
2017
|
* Add a new review.
|
|
2008
2018
|
* If the `x-token` header is send for a valid user, the review will belong to it, otherwise will be added for an anonymouse user
|
|
2009
2019
|
*/
|
|
2010
2020
|
addReview: Review;
|
|
2011
|
-
/** [BETA] Generate a set of consumption based Isolines */
|
|
2012
|
-
createIsoline?: Maybe<Scalars["ID"]>;
|
|
2013
2021
|
/**
|
|
2014
2022
|
* Remove a review added by an authenticated user.
|
|
2015
2023
|
* The `x-token` header is mandatory in order to authorize the user who wants to remove a review.
|
|
2016
|
-
* In case it is not sent, an error will occur.
|
|
2017
|
-
* In case the review was not found or belongs to another user an error will occur.
|
|
2018
|
-
* This is a premium feature, contact Chargetrip for more information.
|
|
2019
|
-
*/
|
|
2020
|
-
deleteUserReview: Review;
|
|
2021
|
-
/**
|
|
2022
|
-
|
|
2023
|
-
/** Create a new route from the route input and its ID */
|
|
2024
|
-
newRoute?: Maybe<Scalars["ID"]>;
|
|
2025
|
-
/** [BETA] Recalculate the current navigation route */
|
|
2026
|
-
recalculateNavigation?: Maybe<Scalars["Void"]>;
|
|
2027
|
-
/** [BETA] Start a new navigation session on top of an existing route */
|
|
2028
|
-
startNavigation?: Maybe<Scalars["ID"]>;
|
|
2029
|
-
/** [BETA] Update the navigation session */
|
|
2030
|
-
updateNavigation?: Maybe<Scalars["Void"]>;
|
|
2031
|
-
};
|
|
2032
|
-
|
|
2033
|
-
export type MutationaddReviewArgs = {
|
|
2034
|
-
review: ReviewAdd;
|
|
2024
|
+
* In case it is not sent, an error will occur.
|
|
2025
|
+
* In case the review was not found or belongs to another user an error will occur.
|
|
2026
|
+
* This is a premium feature, contact Chargetrip for more information.
|
|
2027
|
+
*/
|
|
2028
|
+
deleteUserReview: Review;
|
|
2029
|
+
/** Create a new route from the route input and its ID */
|
|
2030
|
+
newRoute?: Maybe<Scalars["ID"]>;
|
|
2035
2031
|
};
|
|
2036
2032
|
|
|
2037
2033
|
export type MutationcreateIsolineArgs = {
|
|
2038
2034
|
input: IsolineInput;
|
|
2039
2035
|
};
|
|
2040
2036
|
|
|
2041
|
-
export type
|
|
2042
|
-
|
|
2043
|
-
};
|
|
2044
|
-
|
|
2045
|
-
export type MutationfinishNavigationArgs = {
|
|
2046
|
-
input: NavigationFinishInput;
|
|
2037
|
+
export type MutationstartNavigationArgs = {
|
|
2038
|
+
input: NavigationStartInput;
|
|
2047
2039
|
};
|
|
2048
2040
|
|
|
2049
|
-
export type
|
|
2050
|
-
input
|
|
2041
|
+
export type MutationupdateNavigationArgs = {
|
|
2042
|
+
input: NavigationUpdateInput;
|
|
2051
2043
|
};
|
|
2052
2044
|
|
|
2053
2045
|
export type MutationrecalculateNavigationArgs = {
|
|
2054
2046
|
input: NavigationRecalculateInput;
|
|
2055
2047
|
};
|
|
2056
2048
|
|
|
2057
|
-
export type
|
|
2058
|
-
input:
|
|
2049
|
+
export type MutationfinishNavigationArgs = {
|
|
2050
|
+
input: NavigationFinishInput;
|
|
2059
2051
|
};
|
|
2060
2052
|
|
|
2061
|
-
export type
|
|
2062
|
-
|
|
2053
|
+
export type MutationaddReviewArgs = {
|
|
2054
|
+
review: ReviewAdd;
|
|
2055
|
+
};
|
|
2056
|
+
|
|
2057
|
+
export type MutationdeleteUserReviewArgs = {
|
|
2058
|
+
id: Scalars["ID"];
|
|
2059
|
+
};
|
|
2060
|
+
|
|
2061
|
+
export type MutationnewRouteArgs = {
|
|
2062
|
+
input?: Maybe<RequestInput>;
|
|
2063
2063
|
};
|
|
2064
2064
|
|
|
2065
2065
|
/** The navigation session data */
|
|
2066
2066
|
export type Navigation = {
|
|
2067
|
-
/** A set of alternative charging stations to next station */
|
|
2068
|
-
alternative_stations?: Maybe<Array<Maybe<NavigationStation>>>;
|
|
2069
2067
|
/** ID of the navigation session */
|
|
2070
2068
|
id: Scalars["ID"];
|
|
2071
|
-
/** Navigation instructions */
|
|
2072
|
-
instructions?: Maybe<Scalars["JSON"]>;
|
|
2073
|
-
/** Last known location */
|
|
2074
|
-
last_known_location?: Maybe<Point>;
|
|
2075
|
-
/** Next charging station */
|
|
2076
|
-
next_station?: Maybe<NavigationStation>;
|
|
2077
|
-
/** The current route alternative used for navigation */
|
|
2078
|
-
route_alternative_id?: Maybe<Scalars["String"]>;
|
|
2079
2069
|
/** The current route used for navigation */
|
|
2080
2070
|
route_id?: Maybe<Scalars["String"]>;
|
|
2071
|
+
/** The current route alternative used for navigation */
|
|
2072
|
+
route_alternative_id?: Maybe<Scalars["String"]>;
|
|
2081
2073
|
/** The state of a navigation session. The status can be driving, charging, finished, or error */
|
|
2082
2074
|
state?: Maybe<NavigationState>;
|
|
2083
2075
|
/** State of charge at the last known location */
|
|
2084
2076
|
state_of_charge?: Maybe<Scalars["Float"]>;
|
|
2077
|
+
/** Last known location */
|
|
2078
|
+
last_known_location?: Maybe<Point>;
|
|
2079
|
+
/** Next charging station */
|
|
2080
|
+
next_station?: Maybe<NavigationStation>;
|
|
2081
|
+
/** A set of alternative charging stations to next station */
|
|
2082
|
+
alternative_stations?: Maybe<Array<Maybe<NavigationStation>>>;
|
|
2083
|
+
/** Navigation instructions */
|
|
2084
|
+
instructions?: Maybe<Scalars["JSON"]>;
|
|
2085
2085
|
};
|
|
2086
2086
|
|
|
2087
2087
|
/** The navigation session data */
|
|
@@ -2093,80 +2093,80 @@ export type NavigationinstructionsArgs = {
|
|
|
2093
2093
|
|
|
2094
2094
|
/** Input for the navigation recalculate */
|
|
2095
2095
|
export type NavigationFinishInput = {
|
|
2096
|
-
/** Current coordinates */
|
|
2097
|
-
current_location: PointInput;
|
|
2098
2096
|
/** ID of the navigation session */
|
|
2099
2097
|
id: Scalars["ID"];
|
|
2098
|
+
/** Current coordinates */
|
|
2099
|
+
current_location: PointInput;
|
|
2100
2100
|
};
|
|
2101
2101
|
|
|
2102
2102
|
/** Input for the navigation recalculate */
|
|
2103
2103
|
export type NavigationRecalculateInput = {
|
|
2104
|
-
/** Origin location of a new route */
|
|
2105
|
-
current_location: PointInput;
|
|
2106
|
-
/** Heading of a vehicle, in degrees */
|
|
2107
|
-
heading?: Maybe<Scalars["Float"]>;
|
|
2108
2104
|
/** ID of the navigation session */
|
|
2109
2105
|
id: Scalars["ID"];
|
|
2110
2106
|
/** State of charge at origin */
|
|
2111
2107
|
state_of_charge?: Maybe<Scalars["Float"]>;
|
|
2108
|
+
/** Origin location of a new route */
|
|
2109
|
+
current_location: PointInput;
|
|
2112
2110
|
/** Via points of a new route. If this field is not sent, the original via points will be used */
|
|
2113
2111
|
via?: Maybe<Array<Maybe<FeaturePointInput>>>;
|
|
2112
|
+
/** Heading of a vehicle, in degrees */
|
|
2113
|
+
heading?: Maybe<Scalars["Float"]>;
|
|
2114
2114
|
};
|
|
2115
2115
|
|
|
2116
2116
|
/** Input for the navigation start */
|
|
2117
2117
|
export type NavigationStartInput = {
|
|
2118
|
-
/** Current coordinates */
|
|
2119
|
-
current_location: PointInput;
|
|
2120
|
-
/** ID of the route alternative of the navigation session */
|
|
2121
|
-
route_alternative_id?: Maybe<Scalars["String"]>;
|
|
2122
2118
|
/** ID of the route of the navigation session */
|
|
2123
2119
|
route_id: Scalars["String"];
|
|
2120
|
+
/** ID of the route alternative of the navigation session */
|
|
2121
|
+
route_alternative_id?: Maybe<Scalars["String"]>;
|
|
2122
|
+
/** Current coordinates */
|
|
2123
|
+
current_location: PointInput;
|
|
2124
2124
|
};
|
|
2125
2125
|
|
|
2126
2126
|
/** State of navigation session */
|
|
2127
2127
|
export enum NavigationState {
|
|
2128
|
-
/** Vehicle is charging */
|
|
2129
|
-
CHARGING = "charging",
|
|
2130
2128
|
/** Vehicle is driving */
|
|
2131
2129
|
DRIVING = "driving",
|
|
2132
|
-
/**
|
|
2133
|
-
|
|
2130
|
+
/** Vehicle is charging */
|
|
2131
|
+
CHARGING = "charging",
|
|
2134
2132
|
/** Navigation session is completed (either manually or automatically 48 hours after the last update) */
|
|
2135
|
-
FINISHED = "finished"
|
|
2133
|
+
FINISHED = "finished",
|
|
2134
|
+
/** Failed to update navigation session due to route error or not found */
|
|
2135
|
+
ERROR = "error"
|
|
2136
2136
|
}
|
|
2137
2137
|
|
|
2138
2138
|
/** Navigation session station type */
|
|
2139
2139
|
export type NavigationStation = {
|
|
2140
|
-
/** Estimated consumption, in kWh, from last the known location until the next charging station */
|
|
2141
|
-
estimated_consumption?: Maybe<Scalars["Float"]>;
|
|
2142
|
-
/** Estimated duration, in seconds, from the last known location until the next charging station */
|
|
2143
|
-
estimated_duration?: Maybe<Scalars["Int"]>;
|
|
2144
|
-
/** Estimated state of charge, in kWh, at arrival on the next charging station */
|
|
2145
|
-
estimated_state_of_charge?: Maybe<Scalars["Float"]>;
|
|
2146
2140
|
/** The ID as string of the charging station */
|
|
2147
2141
|
station_id?: Maybe<Scalars["String"]>;
|
|
2148
2142
|
/** GPS location of the charging station */
|
|
2149
2143
|
station_location?: Maybe<Point>;
|
|
2150
2144
|
/** An array with all GPS locations of via points until the next charging station */
|
|
2151
2145
|
via?: Maybe<Array<Maybe<Point>>>;
|
|
2146
|
+
/** Estimated state of charge, in kWh, at arrival on the next charging station */
|
|
2147
|
+
estimated_state_of_charge?: Maybe<Scalars["Float"]>;
|
|
2148
|
+
/** Estimated consumption, in kWh, from last the known location until the next charging station */
|
|
2149
|
+
estimated_consumption?: Maybe<Scalars["Float"]>;
|
|
2150
|
+
/** Estimated duration, in seconds, from the last known location until the next charging station */
|
|
2151
|
+
estimated_duration?: Maybe<Scalars["Int"]>;
|
|
2152
2152
|
};
|
|
2153
2153
|
|
|
2154
2154
|
/** Input for the navigation session update telemetry data */
|
|
2155
2155
|
export type NavigationTelemetryUpdateInput = {
|
|
2156
|
-
/** Indicates if a vehicle is charging */
|
|
2157
|
-
is_charging?: Maybe<Scalars["Boolean"]>;
|
|
2158
2156
|
/** State of charge at the last known location, in kwh */
|
|
2159
2157
|
state_of_charge?: Maybe<Scalars["Float"]>;
|
|
2158
|
+
/** Indicates if a vehicle is charging */
|
|
2159
|
+
is_charging?: Maybe<Scalars["Boolean"]>;
|
|
2160
2160
|
/** Average tire pressure, in bars. This information should come from telemetry */
|
|
2161
2161
|
tire_pressure?: Maybe<Scalars["Float"]>;
|
|
2162
2162
|
};
|
|
2163
2163
|
|
|
2164
2164
|
/** Input for the navigation update */
|
|
2165
2165
|
export type NavigationUpdateInput = {
|
|
2166
|
-
/** Heading of a vehicle, in degrees */
|
|
2167
|
-
heading?: Maybe<Scalars["Float"]>;
|
|
2168
2166
|
/** ID of the navigation session */
|
|
2169
2167
|
id: Scalars["ID"];
|
|
2168
|
+
/** Heading of a vehicle, in degrees */
|
|
2169
|
+
heading?: Maybe<Scalars["Float"]>;
|
|
2170
2170
|
/** A list of locations that were collected since the last update */
|
|
2171
2171
|
location_data: Array<NavigationUpdateLocationsInput>;
|
|
2172
2172
|
/** Telemetry data input */
|
|
@@ -2175,14 +2175,14 @@ export type NavigationUpdateInput = {
|
|
|
2175
2175
|
|
|
2176
2176
|
/** Properties of the location */
|
|
2177
2177
|
export type NavigationUpdateLocationPropertiesInput = {
|
|
2178
|
-
/** Altitude information, in meters. This is optional */
|
|
2179
|
-
altitude?: Maybe<Scalars["Int"]>;
|
|
2180
2178
|
/** Current route leg index corresponding to a location */
|
|
2181
2179
|
route_leg: Scalars["Int"];
|
|
2182
2180
|
/** Speed at a location, in km/h */
|
|
2183
2181
|
speed: Scalars["Float"];
|
|
2184
2182
|
/** UNIX timestamp at location, in seconds */
|
|
2185
2183
|
timestamp: Scalars["Int"];
|
|
2184
|
+
/** Altitude information, in meters. This is optional */
|
|
2185
|
+
altitude?: Maybe<Scalars["Int"]>;
|
|
2186
2186
|
};
|
|
2187
2187
|
|
|
2188
2188
|
/** Input for the navigation update locations */
|
|
@@ -2205,10 +2205,10 @@ export type OCPIAdditionalGeoLocation = {
|
|
|
2205
2205
|
|
|
2206
2206
|
/** The capabilities of an EVSE. */
|
|
2207
2207
|
export enum OCPICapability {
|
|
2208
|
-
/** The EVSE supports charging preferences. */
|
|
2209
|
-
CHARGING_PREFERENCES_CAPABLE = "CHARGING_PREFERENCES_CAPABLE",
|
|
2210
2208
|
/** The EVSE supports charging profiles. */
|
|
2211
2209
|
CHARGING_PROFILE_CAPABLE = "CHARGING_PROFILE_CAPABLE",
|
|
2210
|
+
/** The EVSE supports charging preferences. */
|
|
2211
|
+
CHARGING_PREFERENCES_CAPABLE = "CHARGING_PREFERENCES_CAPABLE",
|
|
2212
2212
|
/** EVSE has a payment terminal that supports chip cards. */
|
|
2213
2213
|
CHIP_CARD_SUPPORT = "CHIP_CARD_SUPPORT",
|
|
2214
2214
|
/** EVSE has a payment terminal that supports contactless cards. */
|
|
@@ -2225,28 +2225,26 @@ export enum OCPICapability {
|
|
|
2225
2225
|
RESERVABLE = "RESERVABLE",
|
|
2226
2226
|
/** Charging at this EVSE can be authorized with an RFID token. */
|
|
2227
2227
|
RFID_READER = "RFID_READER",
|
|
2228
|
-
/** When a StartSession is sent to this EVSE, the MSP is required to add the optional connector_id field in the StartSession object. */
|
|
2229
|
-
START_SESSION_CONNECTOR_REQUIRED = "START_SESSION_CONNECTOR_REQUIRED",
|
|
2230
2228
|
/** This EVSE supports token groups, two or more tokens work as one, so that a session can be started with one token and stopped with another (handy when a card and key-fob are given to the EV-driver). */
|
|
2231
2229
|
TOKEN_GROUP_CAPABLE = "TOKEN_GROUP_CAPABLE",
|
|
2232
2230
|
/** Connectors have a mechanical lock that can be requested by the eMSP to be unlocked. */
|
|
2233
|
-
UNLOCK_CAPABLE = "UNLOCK_CAPABLE"
|
|
2231
|
+
UNLOCK_CAPABLE = "UNLOCK_CAPABLE",
|
|
2232
|
+
/** When a StartSession is sent to this EVSE, the MSP is required to add the optional connector_id field in the StartSession object. */
|
|
2233
|
+
START_SESSION_CONNECTOR_REQUIRED = "START_SESSION_CONNECTOR_REQUIRED"
|
|
2234
2234
|
}
|
|
2235
2235
|
|
|
2236
2236
|
/** The format of the connector, whether it is a socket or a plug. */
|
|
2237
2237
|
export enum OCPIConnectorFormat {
|
|
2238
|
-
/** The connector is an attached cable; the EV users car needs to have a fitting inlet. */
|
|
2239
|
-
CABLE = "CABLE",
|
|
2240
2238
|
/** The connector is a socket; the EV user needs to bring a fitting plug. */
|
|
2241
|
-
SOCKET = "SOCKET"
|
|
2239
|
+
SOCKET = "SOCKET",
|
|
2240
|
+
/** The connector is an attached cable; the EV users car needs to have a fitting inlet. */
|
|
2241
|
+
CABLE = "CABLE"
|
|
2242
2242
|
}
|
|
2243
2243
|
|
|
2244
2244
|
/** Deprecated: Please use ConnectorType instead */
|
|
2245
2245
|
export enum OCPIConnectorType {
|
|
2246
2246
|
/** The connector type is CHAdeMO, DC */
|
|
2247
2247
|
CHADEMO = "CHADEMO",
|
|
2248
|
-
/** The ChaoJi connector. The new generation charging connector, harmonized between CHAdeMO and GB/T. DC. */
|
|
2249
|
-
CHAOJI = "CHAOJI",
|
|
2250
2248
|
/** Standard/domestic household, type "A", NEMA 1-15, 2 pins */
|
|
2251
2249
|
DOMESTIC_A = "DOMESTIC_A",
|
|
2252
2250
|
/** Standard/domestic household, type "B", NEMA 5-15, 3 pins */
|
|
@@ -2277,8 +2275,6 @@ export enum OCPIConnectorType {
|
|
|
2277
2275
|
DOMESTIC_N = "DOMESTIC_N",
|
|
2278
2276
|
/** Standard/Domestic household, type "O", TIS 166-2549, 3 pins */
|
|
2279
2277
|
DOMESTIC_O = "DOMESTIC_O",
|
|
2280
|
-
/** The connector type is GB_T (Chinese standard), DC */
|
|
2281
|
-
GB_T = "GB_T",
|
|
2282
2278
|
/** IEC 60309-2 Industrial connector single phase 16 amperes (usually blue) */
|
|
2283
2279
|
IEC_60309_2_SINGLE_16 = "IEC_60309_2_single_16",
|
|
2284
2280
|
/** IEC 60309-2 Industrial connector three phase 16 amperes (usually red) */
|
|
@@ -2299,6 +2295,18 @@ export enum OCPIConnectorType {
|
|
|
2299
2295
|
IEC_62196_T3A = "IEC_62196_T3A",
|
|
2300
2296
|
/** IEC 62196 Type 3C "Scame" */
|
|
2301
2297
|
IEC_62196_T3C = "IEC_62196_T3C",
|
|
2298
|
+
/** On-board bottom-up-pantograph typically for bus charging */
|
|
2299
|
+
PANTOGRAPH_BOTTOM_UP = "PANTOGRAPH_BOTTOM_UP",
|
|
2300
|
+
/** Off-board top-down-pantograph typically for bus charging */
|
|
2301
|
+
PANTOGRAPH_TOP_DOWN = "PANTOGRAPH_TOP_DOWN",
|
|
2302
|
+
/** Tesla connector "Roadster"-type (round, 4 pins) */
|
|
2303
|
+
TESLA_R = "TESLA_R",
|
|
2304
|
+
/** Tesla connector "Model-S"-type (oval, 5 pins) */
|
|
2305
|
+
TESLA_S = "TESLA_S",
|
|
2306
|
+
/** The connector type is GB_T (Chinese standard), DC */
|
|
2307
|
+
GB_T = "GB_T",
|
|
2308
|
+
/** The ChaoJi connector. The new generation charging connector, harmonized between CHAdeMO and GB/T. DC. */
|
|
2309
|
+
CHAOJI = "CHAOJI",
|
|
2302
2310
|
/** The connector type is NEMA 5-20, 3 pins */
|
|
2303
2311
|
NEMA_5_20 = "NEMA_5_20",
|
|
2304
2312
|
/** The connector type is NEMA 6-30, 3 pins */
|
|
@@ -2312,25 +2320,17 @@ export enum OCPIConnectorType {
|
|
|
2312
2320
|
/** The connector type is NEMA 14-30, 3 pins, rating of 30 A */
|
|
2313
2321
|
NEMA_14_30 = "NEMA_14_30",
|
|
2314
2322
|
/** The connector type is NEMA 14-50, 3 pins, rating of 50 A */
|
|
2315
|
-
NEMA_14_50 = "NEMA_14_50"
|
|
2316
|
-
/** On-board bottom-up-pantograph typically for bus charging */
|
|
2317
|
-
PANTOGRAPH_BOTTOM_UP = "PANTOGRAPH_BOTTOM_UP",
|
|
2318
|
-
/** Off-board top-down-pantograph typically for bus charging */
|
|
2319
|
-
PANTOGRAPH_TOP_DOWN = "PANTOGRAPH_TOP_DOWN",
|
|
2320
|
-
/** Tesla connector "Roadster"-type (round, 4 pins) */
|
|
2321
|
-
TESLA_R = "TESLA_R",
|
|
2322
|
-
/** Tesla connector "Model-S"-type (oval, 5 pins) */
|
|
2323
|
-
TESLA_S = "TESLA_S"
|
|
2323
|
+
NEMA_14_50 = "NEMA_14_50"
|
|
2324
2324
|
}
|
|
2325
2325
|
|
|
2326
2326
|
export enum OCPIDayOfWeek {
|
|
2327
|
-
FRIDAY = "FRIDAY",
|
|
2328
2327
|
MONDAY = "MONDAY",
|
|
2329
|
-
SATURDAY = "SATURDAY",
|
|
2330
|
-
SUNDAY = "SUNDAY",
|
|
2331
|
-
THURSDAY = "THURSDAY",
|
|
2332
2328
|
TUESDAY = "TUESDAY",
|
|
2333
|
-
WEDNESDAY = "WEDNESDAY"
|
|
2329
|
+
WEDNESDAY = "WEDNESDAY",
|
|
2330
|
+
THURSDAY = "THURSDAY",
|
|
2331
|
+
FRIDAY = "FRIDAY",
|
|
2332
|
+
SATURDAY = "SATURDAY",
|
|
2333
|
+
SUNDAY = "SUNDAY"
|
|
2334
2334
|
}
|
|
2335
2335
|
|
|
2336
2336
|
export type OCPIDisplayText = {
|
|
@@ -2342,59 +2342,59 @@ export type OCPIDisplayText = {
|
|
|
2342
2342
|
|
|
2343
2343
|
/** This type is used to specify the energy mix and environmental impact of the supplied energy at a location or in a tariff. */
|
|
2344
2344
|
export type OCPIEnergyMix = {
|
|
2345
|
-
/**
|
|
2346
|
-
|
|
2345
|
+
/** True if the power is 100% from regenerative sources */
|
|
2346
|
+
is_green_energy?: Maybe<Scalars["Boolean"]>;
|
|
2347
2347
|
/** Key-value pairs (enum + percentage) of energy sources of this location’s tariff. */
|
|
2348
2348
|
energy_sources?: Maybe<Array<Maybe<OCPIEnergySource>>>;
|
|
2349
2349
|
/** Key-value pairs (enum + percentage) of nuclear waste and CO2 exhaust of this location’s tariff. */
|
|
2350
2350
|
environ_impact?: Maybe<Array<Maybe<OCPIEnvironmentalImpact>>>;
|
|
2351
|
-
/** True if the power is 100% from regenerative sources */
|
|
2352
|
-
is_green_energy?: Maybe<Scalars["Boolean"]>;
|
|
2353
2351
|
/** Name of the energy supplier, delivering the energy for this location or tariff.* */
|
|
2354
2352
|
supplier_name?: Maybe<Scalars["String"]>;
|
|
2353
|
+
/** Name of the energy suppliers product/tariff plan used at this location.* */
|
|
2354
|
+
energy_product_name?: Maybe<Scalars["String"]>;
|
|
2355
2355
|
};
|
|
2356
2356
|
|
|
2357
2357
|
export type OCPIEnergySource = {
|
|
2358
|
-
/** Percentage of this source (0-100) in the mix. */
|
|
2359
|
-
percentage?: Maybe<Scalars["Int"]>;
|
|
2360
2358
|
/** The type of energy source. */
|
|
2361
2359
|
source?: Maybe<OCPIEnergySourceCategory>;
|
|
2360
|
+
/** Percentage of this source (0-100) in the mix. */
|
|
2361
|
+
percentage?: Maybe<Scalars["Int"]>;
|
|
2362
2362
|
};
|
|
2363
2363
|
|
|
2364
2364
|
/** Categories of energy sources. */
|
|
2365
2365
|
export enum OCPIEnergySourceCategory {
|
|
2366
|
+
/** Nuclear power sources. */
|
|
2367
|
+
NUCLEAR = "NUCLEAR",
|
|
2368
|
+
/** All kinds of fossil power sources. */
|
|
2369
|
+
GENERAL_FOSSIL = "GENERAL_FOSSIL",
|
|
2366
2370
|
/** Fossil power from coal. */
|
|
2367
2371
|
COAL = "COAL",
|
|
2368
2372
|
/** Fossil power from gas. */
|
|
2369
2373
|
GAS = "GAS",
|
|
2370
|
-
/** All kinds of fossil power sources. */
|
|
2371
|
-
GENERAL_FOSSIL = "GENERAL_FOSSIL",
|
|
2372
2374
|
/** All kinds of regenerative power sources. */
|
|
2373
2375
|
GENERAL_GREEN = "GENERAL_GREEN",
|
|
2374
|
-
/** Nuclear power sources. */
|
|
2375
|
-
NUCLEAR = "NUCLEAR",
|
|
2376
2376
|
/** Regenerative power from PV. */
|
|
2377
2377
|
SOLAR = "SOLAR",
|
|
2378
|
-
/** Regenerative power from water turbines. */
|
|
2379
|
-
WATER = "WATER",
|
|
2380
2378
|
/** Regenerative power from wind turbines. */
|
|
2381
|
-
WIND = "WIND"
|
|
2379
|
+
WIND = "WIND",
|
|
2380
|
+
/** Regenerative power from water turbines. */
|
|
2381
|
+
WATER = "WATER"
|
|
2382
2382
|
}
|
|
2383
2383
|
|
|
2384
2384
|
/** Amount of waste produced/emitted per kWh. */
|
|
2385
2385
|
export type OCPIEnvironmentalImpact = {
|
|
2386
|
-
/** Amount of this portion in g/kWh. */
|
|
2387
|
-
amount?: Maybe<Scalars["Int"]>;
|
|
2388
2386
|
/** The environmental impact category of this value. */
|
|
2389
2387
|
category?: Maybe<OCPIEnvironmentalImpactCategory>;
|
|
2388
|
+
/** Amount of this portion in g/kWh. */
|
|
2389
|
+
amount?: Maybe<Scalars["Int"]>;
|
|
2390
2390
|
};
|
|
2391
2391
|
|
|
2392
2392
|
/** Categories of environmental impact values. */
|
|
2393
2393
|
export enum OCPIEnvironmentalImpactCategory {
|
|
2394
|
-
/** Exhausted carbon dioxide in grams per kilowatthour. */
|
|
2395
|
-
CARBON_DIOXIDE = "CARBON_DIOXIDE",
|
|
2396
2394
|
/** Produced nuclear waste in grams per kilowatthour. */
|
|
2397
|
-
NUCLEAR_WASTE = "NUCLEAR_WASTE"
|
|
2395
|
+
NUCLEAR_WASTE = "NUCLEAR_WASTE",
|
|
2396
|
+
/** Exhausted carbon dioxide in grams per kilowatthour. */
|
|
2397
|
+
CARBON_DIOXIDE = "CARBON_DIOXIDE"
|
|
2398
2398
|
}
|
|
2399
2399
|
|
|
2400
2400
|
/** Specifies one exceptional period for opening or access hours. */
|
|
@@ -2406,44 +2406,44 @@ export type OCPIExceptionalPeriod = {
|
|
|
2406
2406
|
};
|
|
2407
2407
|
|
|
2408
2408
|
export enum OCPIFacility {
|
|
2409
|
-
/** An airport. */
|
|
2410
|
-
AIRPORT = "AIRPORT",
|
|
2411
|
-
/** A bike/e-bike/e-scooter sharing location. */
|
|
2412
|
-
BIKE_SHARING = "BIKE_SHARING",
|
|
2413
|
-
/** A bus stop. */
|
|
2414
|
-
BUS_STOP = "BUS_STOP",
|
|
2415
|
-
/** A cafe. */
|
|
2416
|
-
CAFE = "CAFE",
|
|
2417
|
-
/** A carpool parking. */
|
|
2418
|
-
CARPOOL_PARKING = "CARPOOL_PARKING",
|
|
2419
|
-
/** A Fuel station. */
|
|
2420
|
-
FUEL_STATION = "FUEL_STATION",
|
|
2421
2409
|
/** A hotel. */
|
|
2422
2410
|
HOTEL = "HOTEL",
|
|
2423
|
-
/** A mall or shopping center. */
|
|
2424
|
-
MALL = "MALL",
|
|
2425
|
-
/** A metro station. */
|
|
2426
|
-
METRO_STATION = "METRO_STATION",
|
|
2427
|
-
/** A museum. */
|
|
2428
|
-
MUSEUM = "MUSEUM",
|
|
2429
|
-
/** Located in, or close to, a park, nature reserve etc. */
|
|
2430
|
-
NATURE = "NATURE",
|
|
2431
|
-
/** A parking lot. */
|
|
2432
|
-
PARKING_LOT = "PARKING_LOT",
|
|
2433
|
-
/** A recreation area. */
|
|
2434
|
-
RECREATION_AREA = "RECREATION_AREA",
|
|
2435
2411
|
/** A restaurant. */
|
|
2436
2412
|
RESTAURANT = "RESTAURANT",
|
|
2437
|
-
/**
|
|
2438
|
-
|
|
2413
|
+
/** A cafe. */
|
|
2414
|
+
CAFE = "CAFE",
|
|
2415
|
+
/** A mall or shopping center. */
|
|
2416
|
+
MALL = "MALL",
|
|
2439
2417
|
/** A supermarket. */
|
|
2440
2418
|
SUPERMARKET = "SUPERMARKET",
|
|
2419
|
+
/** Sport facilities: gym, field etc. */
|
|
2420
|
+
SPORT = "SPORT",
|
|
2421
|
+
/** A recreation area. */
|
|
2422
|
+
RECREATION_AREA = "RECREATION_AREA",
|
|
2423
|
+
/** Located in, or close to, a park, nature reserve etc. */
|
|
2424
|
+
NATURE = "NATURE",
|
|
2425
|
+
/** A museum. */
|
|
2426
|
+
MUSEUM = "MUSEUM",
|
|
2427
|
+
/** A bike/e-bike/e-scooter sharing location. */
|
|
2428
|
+
BIKE_SHARING = "BIKE_SHARING",
|
|
2429
|
+
/** A bus stop. */
|
|
2430
|
+
BUS_STOP = "BUS_STOP",
|
|
2441
2431
|
/** A taxi stand. */
|
|
2442
2432
|
TAXI_STAND = "TAXI_STAND",
|
|
2443
|
-
/** A train station. */
|
|
2444
|
-
TRAIN_STATION = "TRAIN_STATION",
|
|
2445
2433
|
/** A tram stop/station. */
|
|
2446
2434
|
TRAM_STOP = "TRAM_STOP",
|
|
2435
|
+
/** A metro station. */
|
|
2436
|
+
METRO_STATION = "METRO_STATION",
|
|
2437
|
+
/** A train station. */
|
|
2438
|
+
TRAIN_STATION = "TRAIN_STATION",
|
|
2439
|
+
/** An airport. */
|
|
2440
|
+
AIRPORT = "AIRPORT",
|
|
2441
|
+
/** A parking lot. */
|
|
2442
|
+
PARKING_LOT = "PARKING_LOT",
|
|
2443
|
+
/** A carpool parking. */
|
|
2444
|
+
CARPOOL_PARKING = "CARPOOL_PARKING",
|
|
2445
|
+
/** A Fuel station. */
|
|
2446
|
+
FUEL_STATION = "FUEL_STATION",
|
|
2447
2447
|
/** Wifi or other type of internet available. */
|
|
2448
2448
|
WIFI = "WIFI"
|
|
2449
2449
|
}
|
|
@@ -2458,29 +2458,29 @@ export type OCPIGeoLocation = {
|
|
|
2458
2458
|
|
|
2459
2459
|
/** Opening and access hours of the location. */
|
|
2460
2460
|
export type OCPIHours = {
|
|
2461
|
-
/** Exceptions for specified calendar dates, time-range based. Periods the station is not operating/accessible. Overwriting regular_hours and exceptional_openings. Should not overlap exceptional_openings. */
|
|
2462
|
-
exceptional_closings?: Maybe<Array<Maybe<OCPIExceptionalPeriod>>>;
|
|
2463
|
-
/** Exceptions for specified calendar dates, time-range based. Periods the station is operating/accessible. Additional to regular_hours. May overlap regular rules. */
|
|
2464
|
-
exceptional_openings?: Maybe<Array<Maybe<OCPIExceptionalPeriod>>>;
|
|
2465
|
-
/** Regular hours, weekday-based. Only to be used if twentyfourseven=false, then this field needs to contain at least one RegularHours object. */
|
|
2466
|
-
regular_hours?: Maybe<Array<Maybe<OCPIRegularHours>>>;
|
|
2467
2461
|
/** True to represent 24 hours a day and 7 days a week, except the given exceptions. */
|
|
2468
2462
|
twentyfourseven?: Maybe<Scalars["Boolean"]>;
|
|
2463
|
+
/** Regular hours, weekday-based. Only to be used if twentyfourseven=false, then this field needs to contain at least one RegularHours object. */
|
|
2464
|
+
regular_hours?: Maybe<Array<Maybe<OCPIRegularHours>>>;
|
|
2465
|
+
/** Exceptions for specified calendar dates, time-range based. Periods the station is operating/accessible. Additional to regular_hours. May overlap regular rules. */
|
|
2466
|
+
exceptional_openings?: Maybe<Array<Maybe<OCPIExceptionalPeriod>>>;
|
|
2467
|
+
/** Exceptions for specified calendar dates, time-range based. Periods the station is not operating/accessible. Overwriting regular_hours and exceptional_openings. Should not overlap exceptional_openings. */
|
|
2468
|
+
exceptional_closings?: Maybe<Array<Maybe<OCPIExceptionalPeriod>>>;
|
|
2469
2469
|
};
|
|
2470
2470
|
|
|
2471
2471
|
export type OCPIImage = {
|
|
2472
|
-
/**
|
|
2473
|
-
|
|
2474
|
-
/** Height of the full scale image */
|
|
2475
|
-
height?: Maybe<Scalars["Int"]>;
|
|
2472
|
+
/** URL from where the image data can be fetched through a web browser. */
|
|
2473
|
+
url?: Maybe<Scalars["String"]>;
|
|
2476
2474
|
/** URL from where a thumbnail of the image can be fetched through a webbrowser. */
|
|
2477
2475
|
thumbnail?: Maybe<Scalars["String"]>;
|
|
2476
|
+
/** Category of an image */
|
|
2477
|
+
category?: Maybe<OCPIImageCategory>;
|
|
2478
2478
|
/** Image type: gif, jpeg, png, svg */
|
|
2479
2479
|
type?: Maybe<Scalars["String"]>;
|
|
2480
|
-
/** URL from where the image data can be fetched through a web browser. */
|
|
2481
|
-
url?: Maybe<Scalars["String"]>;
|
|
2482
2480
|
/** Width of the full scale image */
|
|
2483
2481
|
width?: Maybe<Scalars["Int"]>;
|
|
2482
|
+
/** Height of the full scale image */
|
|
2483
|
+
height?: Maybe<Scalars["Int"]>;
|
|
2484
2484
|
};
|
|
2485
2485
|
|
|
2486
2486
|
/** The category of an image to obtain the correct usage in a user presentation. The category has to be set accordingly to the image content in order to guarantee the right usage. */
|
|
@@ -2503,30 +2503,30 @@ export enum OCPIImageCategory {
|
|
|
2503
2503
|
|
|
2504
2504
|
/** This value, if provided, represents the restriction to the parking spot for different purposes. */
|
|
2505
2505
|
export enum OCPIParkingRestriction {
|
|
2506
|
-
/** Parking spot for customers/guests only, for example in case of a hotel or shop. */
|
|
2507
|
-
CUSTOMERS = "CUSTOMERS",
|
|
2508
|
-
/** Reserved parking spot for disabled people with valid ID. */
|
|
2509
|
-
DISABLED = "DISABLED",
|
|
2510
2506
|
/** Reserved parking spot for electric vehicles. */
|
|
2511
2507
|
EV_ONLY = "EV_ONLY",
|
|
2508
|
+
/** Parking is only allowed while plugged in (charging). */
|
|
2509
|
+
PLUGGED = "PLUGGED",
|
|
2510
|
+
/** Reserved parking spot for disabled people with valid ID. */
|
|
2511
|
+
DISABLED = "DISABLED",
|
|
2512
|
+
/** Parking spot for customers/guests only, for example in case of a hotel or shop. */
|
|
2513
|
+
CUSTOMERS = "CUSTOMERS",
|
|
2512
2514
|
/** Parking spot only suitable for (electric) motorcycles or scooters. */
|
|
2513
|
-
MOTORCYCLES = "MOTORCYCLES"
|
|
2514
|
-
/** Parking is only allowed while plugged in (charging). */
|
|
2515
|
-
PLUGGED = "PLUGGED"
|
|
2515
|
+
MOTORCYCLES = "MOTORCYCLES"
|
|
2516
2516
|
}
|
|
2517
2517
|
|
|
2518
2518
|
/** Reflects the general type of the charge point’s location. May be used for user information. */
|
|
2519
2519
|
export enum OCPIParkingType {
|
|
2520
2520
|
/** Location on a parking facility/rest area along a motorway, freeway, interstate, highway etc. */
|
|
2521
2521
|
ALONG_MOTORWAY = "ALONG_MOTORWAY",
|
|
2522
|
-
/** Location is on the driveway of a house/building. */
|
|
2523
|
-
ON_DRIVEWAY = "ON_DRIVEWAY",
|
|
2524
|
-
/** Parking in public space along a street. */
|
|
2525
|
-
ON_STREET = "ON_STREET",
|
|
2526
2522
|
/** Multistorey car park. */
|
|
2527
2523
|
PARKING_GARAGE = "PARKING_GARAGE",
|
|
2528
2524
|
/** A cleared area that is intended for parking vehicles, i.e. at supermarkets, bars, etc. */
|
|
2529
2525
|
PARKING_LOT = "PARKING_LOT",
|
|
2526
|
+
/** Location is on the driveway of a house/building. */
|
|
2527
|
+
ON_DRIVEWAY = "ON_DRIVEWAY",
|
|
2528
|
+
/** Parking in public space along a street. */
|
|
2529
|
+
ON_STREET = "ON_STREET",
|
|
2530
2530
|
/** Multistorey car park, mainly underground. */
|
|
2531
2531
|
UNDERGROUND_GARAGE = "UNDERGROUND_GARAGE"
|
|
2532
2532
|
}
|
|
@@ -2534,12 +2534,12 @@ export enum OCPIParkingType {
|
|
|
2534
2534
|
export enum OCPIPowerType {
|
|
2535
2535
|
/** AC single phase. */
|
|
2536
2536
|
AC_1_PHASE = "AC_1_PHASE",
|
|
2537
|
+
/** AC three phase. */
|
|
2538
|
+
AC_3_PHASE = "AC_3_PHASE",
|
|
2537
2539
|
/** AC two phases, only two of the three available phases connected. */
|
|
2538
2540
|
AC_2_PHASE = "AC_2_PHASE",
|
|
2539
2541
|
/** AC two phases using split phase system. */
|
|
2540
2542
|
AC_2_PHASE_SPLIT = "AC_2_PHASE_SPLIT",
|
|
2541
|
-
/** AC three phase. */
|
|
2542
|
-
AC_3_PHASE = "AC_3_PHASE",
|
|
2543
2543
|
/** Direct Current. */
|
|
2544
2544
|
DC = "DC"
|
|
2545
2545
|
}
|
|
@@ -2552,24 +2552,24 @@ export type OCPIPrice = {
|
|
|
2552
2552
|
};
|
|
2553
2553
|
|
|
2554
2554
|
export type OCPIPriceComponent = {
|
|
2555
|
-
/** Price per unit (excl. VAT) for this tariff dimension. */
|
|
2556
|
-
price?: Maybe<Scalars["Float"]>;
|
|
2557
|
-
/** Minimum amount to be billed. This unit will be billed in this step_size blocks. For example: if type is TIME and step_size has a value of 300, then time will be billed in blocks of 5 minutes. If 6 minutes were used, 10 minutes (2 blocks of step_size) will be billed. */
|
|
2558
|
-
step_size?: Maybe<Scalars["Int"]>;
|
|
2559
2555
|
/** Type of tariff dimension. */
|
|
2560
2556
|
type?: Maybe<OCPITariffDimensionType>;
|
|
2557
|
+
/** Price per unit (excl. VAT) for this tariff dimension. */
|
|
2558
|
+
price?: Maybe<Scalars["Float"]>;
|
|
2561
2559
|
/** Applicable VAT percentage for this tariff dimension. If omitted, no VAT is applicable. Not providing a VAT is different from 0% VAT, which would be a value of 0.0 here. */
|
|
2562
2560
|
vat?: Maybe<Scalars["Float"]>;
|
|
2561
|
+
/** Minimum amount to be billed. This unit will be billed in this step_size blocks. For example: if type is TIME and step_size has a value of 300, then time will be billed in blocks of 5 minutes. If 6 minutes were used, 10 minutes (2 blocks of step_size) will be billed. */
|
|
2562
|
+
step_size?: Maybe<Scalars["Int"]>;
|
|
2563
2563
|
};
|
|
2564
2564
|
|
|
2565
2565
|
/** Regular recurring operation or access hours. */
|
|
2566
2566
|
export type OCPIRegularHours = {
|
|
2567
|
+
/** Number of days in the week, from Monday (1) till Sunday (7) */
|
|
2568
|
+
weekday?: Maybe<Scalars["Int"]>;
|
|
2567
2569
|
/** Begin of the regular period, in local time, given in hours and minutes. Must be in 24h format with leading zeros. Example: "18:15". Hour/Minute separator: ":" Regex: ([0-1][0-9]|2[1-3]):[0-5][0-9]. */
|
|
2568
2570
|
period_begin?: Maybe<Scalars["String"]>;
|
|
2569
2571
|
/** End of the regular period, in local time, syntax as for period_begin. Must be later than period_begin. */
|
|
2570
2572
|
period_end?: Maybe<Scalars["String"]>;
|
|
2571
|
-
/** Number of days in the week, from Monday (1) till Sunday (7) */
|
|
2572
|
-
weekday?: Maybe<Scalars["Int"]>;
|
|
2573
2573
|
};
|
|
2574
2574
|
|
|
2575
2575
|
export enum OCPIReservationRestrictionType {
|
|
@@ -2614,32 +2614,32 @@ export type OCPIStatusSchedule = {
|
|
|
2614
2614
|
export type OCPITariff = {
|
|
2615
2615
|
/** ISO-3166 alpha-2 country code of the CPO that owns this tariff */
|
|
2616
2616
|
country_code?: Maybe<Scalars["String"]>;
|
|
2617
|
+
/** CPO ID of the CPO that owns this tariff (following the ISO-15118 standard) */
|
|
2618
|
+
party_id?: Maybe<Scalars["String"]>;
|
|
2619
|
+
/** Uniquely identifies the tariff within the CPO’s platform (and suboperator platforms) */
|
|
2620
|
+
id?: Maybe<Scalars["String"]>;
|
|
2617
2621
|
/** ISO-4217 code of the currency of this tariff. */
|
|
2618
2622
|
currency?: Maybe<Scalars["String"]>;
|
|
2623
|
+
/** Defines the type of the tariff. This allows for distinction in case of given charging preferences. When omitted, this tariff is valid for all sessions */
|
|
2624
|
+
type?: Maybe<OCPITariffType>;
|
|
2625
|
+
/** List of alternative tariff information texts, in multiple languages */
|
|
2626
|
+
tariff_alt_text?: Maybe<Array<Maybe<OCPIDisplayText>>>;
|
|
2627
|
+
/** URL to a web page that contains an explanation of the tariff information in human readable form */
|
|
2628
|
+
tariff_alt_url?: Maybe<Scalars["String"]>;
|
|
2629
|
+
/** When this field is set, a charging session with this tariff will cost at least the amount shown. This is different from a FLAT fee (start tariff, transaction fee), as a FLAT fee is a fixed amount that must be paid for any charging session. A minimum price indicates that when the cost of a charging session is lower than this amount, the cost of the session will be equal to this amount */
|
|
2630
|
+
min_price?: Maybe<OCPIPrice>;
|
|
2631
|
+
/** When this field is set, a charging session with this tariff will NOT cost more than this amount */
|
|
2632
|
+
max_price?: Maybe<OCPIPrice>;
|
|
2619
2633
|
/** List of tariff elements */
|
|
2620
2634
|
elements?: Maybe<Array<Maybe<OCPITariffElement>>>;
|
|
2635
|
+
/** Time when this tariff becomes active, in UTC, time_zone field of the Location can be used to convert to local time. Typically used for a new tariff that is already given with the location, before it becomes active */
|
|
2636
|
+
start_date_time?: Maybe<Scalars["DateTime"]>;
|
|
2621
2637
|
/** Time after which this tariff is no longer valid, in UTC, time_zone field if the location can be used to convert to local time. Typically used when this tariff is going to be replaced with a different tariff in the near future */
|
|
2622
2638
|
end_date_time?: Maybe<Scalars["DateTime"]>;
|
|
2623
2639
|
/** Details about the energy supplied with this tariff */
|
|
2624
2640
|
energy_mix?: Maybe<OCPIEnergyMix>;
|
|
2625
|
-
/** Uniquely identifies the tariff within the CPO’s platform (and suboperator platforms) */
|
|
2626
|
-
id?: Maybe<Scalars["String"]>;
|
|
2627
2641
|
/** Timestamp when this tariff was last updated (or created) */
|
|
2628
2642
|
last_updated?: Maybe<Scalars["DateTime"]>;
|
|
2629
|
-
/** When this field is set, a charging session with this tariff will NOT cost more than this amount */
|
|
2630
|
-
max_price?: Maybe<OCPIPrice>;
|
|
2631
|
-
/** When this field is set, a charging session with this tariff will cost at least the amount shown. This is different from a FLAT fee (start tariff, transaction fee), as a FLAT fee is a fixed amount that must be paid for any charging session. A minimum price indicates that when the cost of a charging session is lower than this amount, the cost of the session will be equal to this amount */
|
|
2632
|
-
min_price?: Maybe<OCPIPrice>;
|
|
2633
|
-
/** CPO ID of the CPO that owns this tariff (following the ISO-15118 standard) */
|
|
2634
|
-
party_id?: Maybe<Scalars["String"]>;
|
|
2635
|
-
/** Time when this tariff becomes active, in UTC, time_zone field of the Location can be used to convert to local time. Typically used for a new tariff that is already given with the location, before it becomes active */
|
|
2636
|
-
start_date_time?: Maybe<Scalars["DateTime"]>;
|
|
2637
|
-
/** List of alternative tariff information texts, in multiple languages */
|
|
2638
|
-
tariff_alt_text?: Maybe<Array<Maybe<OCPIDisplayText>>>;
|
|
2639
|
-
/** URL to a web page that contains an explanation of the tariff information in human readable form */
|
|
2640
|
-
tariff_alt_url?: Maybe<Scalars["String"]>;
|
|
2641
|
-
/** Defines the type of the tariff. This allows for distinction in case of given charging preferences. When omitted, this tariff is valid for all sessions */
|
|
2642
|
-
type?: Maybe<OCPITariffType>;
|
|
2643
2643
|
};
|
|
2644
2644
|
|
|
2645
2645
|
export enum OCPITariffDimensionType {
|
|
@@ -2661,34 +2661,34 @@ export type OCPITariffElement = {
|
|
|
2661
2661
|
};
|
|
2662
2662
|
|
|
2663
2663
|
export type OCPITariffRestrictions = {
|
|
2664
|
-
/**
|
|
2665
|
-
|
|
2666
|
-
/** End date in local time, the time zone is defined in the time_zone field of the Location, for example: 2015-12-27, valid until this day (exclusive). Same syntax as start_date */
|
|
2667
|
-
end_date?: Maybe<Scalars["String"]>;
|
|
2664
|
+
/** Start time of day in local time, the time zone is defined in the time_zone field of the Location, for example 13:30, valid from this time of the day. Must be in 24h format with leading zeros. Hour/Minute separator: ":" Regex: ([0-1][0-9]|2[1-3]):[0-5][0-9] */
|
|
2665
|
+
start_time?: Maybe<Scalars["String"]>;
|
|
2668
2666
|
/** End time of day in local time, the time zone is defined in the time_zone field of the Location, for example 19:45, valid until this time of the day. Same syntax as start_time. */
|
|
2669
2667
|
end_time?: Maybe<Scalars["String"]>;
|
|
2670
|
-
/**
|
|
2671
|
-
|
|
2672
|
-
/**
|
|
2673
|
-
|
|
2668
|
+
/** Start date in local time, the time zone is defined in the time_zone field of the Location, for example: 2015-12-24, valid from this day. Regex: ([12][0-9]{3})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01]) */
|
|
2669
|
+
start_date?: Maybe<Scalars["String"]>;
|
|
2670
|
+
/** End date in local time, the time zone is defined in the time_zone field of the Location, for example: 2015-12-27, valid until this day (exclusive). Same syntax as start_date */
|
|
2671
|
+
end_date?: Maybe<Scalars["String"]>;
|
|
2672
|
+
/** Minimum consumed energy in kWh, for example 20, valid from this amount of energy being used */
|
|
2673
|
+
min_kwh?: Maybe<Scalars["Float"]>;
|
|
2674
2674
|
/** Maximum consumed energy in kWh, for example 50, valid until this amount of energy being used */
|
|
2675
2675
|
max_kwh?: Maybe<Scalars["Float"]>;
|
|
2676
|
-
/** Maximum power in kW, for example 20. When the EV is charging with less than the defined amount of power, this tariff element becomes/is active. If the charging power is or becomes higher, this tariff element is not or no longer valid and becomes inactive. This does not describe the maximum power over the entire charging session. This restriction can make a tariff element become active when the charging power is below this value, but the TariffElement MUST no longer be active when the charging power raises above the defined value */
|
|
2677
|
-
max_power?: Maybe<Scalars["Float"]>;
|
|
2678
2676
|
/** Sum of the minimum current in over all phases, for example 5. When the EV is charging with more than the defined amount of current, this tariff element is/becomes active. If the charging current is or becomes lower, this tariff element is not or no longer valid and becomes inactive. This does not describe the minimum current over the entire charging session. This restriction can make a tariff element become active when the charging current is above the defined value, but the tariff element MUST no longer be active when the charging current drops below the defined value */
|
|
2679
2677
|
min_current?: Maybe<Scalars["Float"]>;
|
|
2680
|
-
/**
|
|
2681
|
-
|
|
2682
|
-
/** Minimum consumed energy in kWh, for example 20, valid from this amount of energy being used */
|
|
2683
|
-
min_kwh?: Maybe<Scalars["Float"]>;
|
|
2678
|
+
/** Sum of the maximum current in over all phases, for example 20. When the EV is charging with less than the defined amount of current, this tariff element becomes/is active. If the charging current is or becomes higher, this tariff element is not or no longer valid and becomes inactive. This describes NOT the maximum current over the entire Charging Session. This restriction can make a tariff element become active when the charging current is below this value, but the tariff element MUST no longer be active when the charging current raises above the defined value */
|
|
2679
|
+
max_current?: Maybe<Scalars["Float"]>;
|
|
2684
2680
|
/** Minimum power in kW, for example 5. When the EV is charging with more than the defined amount of power, this tariff element is/becomes active. If the charging power is or becomes lower, this tariff element is not or no longer valid and becomes inactive. This does not describe the minimum power over the entire charging session. This restriction can make a tariff element become active when the charging power is above this value, but the TariffElement MUST no longer be active when the charging power drops below the defined value */
|
|
2685
2681
|
min_power?: Maybe<Scalars["Float"]>;
|
|
2682
|
+
/** Maximum power in kW, for example 20. When the EV is charging with less than the defined amount of power, this tariff element becomes/is active. If the charging power is or becomes higher, this tariff element is not or no longer valid and becomes inactive. This does not describe the maximum power over the entire charging session. This restriction can make a tariff element become active when the charging power is below this value, but the TariffElement MUST no longer be active when the charging power raises above the defined value */
|
|
2683
|
+
max_power?: Maybe<Scalars["Float"]>;
|
|
2684
|
+
/** Minimum duration in seconds the charging session MUST last (inclusive). When the duration of a charging session is longer than the defined value, this TariffElement is or becomes active. Before that moment, this tariff element is not yet active */
|
|
2685
|
+
min_duration?: Maybe<Scalars["Float"]>;
|
|
2686
|
+
/** Maximum duration in seconds the charging session MUST last (exclusive). When the duration of a charging session is shorter than the defined value, this tariff element is or becomes active. After that moment, this tariff element is no longer active */
|
|
2687
|
+
max_duration?: Maybe<Scalars["Float"]>;
|
|
2688
|
+
/** Which day(s) of the week this tariff element is active. */
|
|
2689
|
+
day_of_week?: Maybe<OCPIDayOfWeek>;
|
|
2686
2690
|
/** When this field is present, the tariff element describes reservation costs. A reservation starts when the reservation is made, and ends when the drivers starts charging on the reserved EVSE/Location, or when the reservation expires. A reservation can only have: FLAT and TIME TariffDimensions, where TIME is for the duration of the reservation */
|
|
2687
2691
|
reservation?: Maybe<OCPIReservationRestrictionType>;
|
|
2688
|
-
/** Start date in local time, the time zone is defined in the time_zone field of the Location, for example: 2015-12-24, valid from this day. Regex: ([12][0-9]{3})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01]) */
|
|
2689
|
-
start_date?: Maybe<Scalars["String"]>;
|
|
2690
|
-
/** Start time of day in local time, the time zone is defined in the time_zone field of the Location, for example 13:30, valid from this time of the day. Must be in 24h format with leading zeros. Hour/Minute separator: ":" Regex: ([0-1][0-9]|2[1-3]):[0-5][0-9] */
|
|
2691
|
-
start_time?: Maybe<Scalars["String"]>;
|
|
2692
2692
|
};
|
|
2693
2693
|
|
|
2694
2694
|
export enum OCPITariffType {
|
|
@@ -2706,48 +2706,48 @@ export enum OCPITariffType {
|
|
|
2706
2706
|
|
|
2707
2707
|
/** The operator data which extends OCPI BusinessDetails */
|
|
2708
2708
|
export type Operator = {
|
|
2709
|
-
/** Contact information */
|
|
2710
|
-
contact?: Maybe<Contact>;
|
|
2711
|
-
/** ISO-3166 alpha-2 country codes an operator is active in. */
|
|
2712
|
-
countries?: Maybe<Array<CountryCodeAlpha2>>;
|
|
2713
|
-
/** Deprecated: Not used anymore, please use countries property instead */
|
|
2714
|
-
country?: Maybe<Scalars["String"]>;
|
|
2715
|
-
/** Flag which indicates if the operator is in the excluded list */
|
|
2716
|
-
excluded?: Maybe<Scalars["Boolean"]>;
|
|
2717
|
-
/** External ID of an operator provided by the operator data source */
|
|
2718
|
-
external_id?: Maybe<Scalars["String"]>;
|
|
2719
2709
|
/** Unique operator ID */
|
|
2720
2710
|
id?: Maybe<Scalars["ID"]>;
|
|
2721
|
-
/**
|
|
2722
|
-
|
|
2711
|
+
/** External ID of an operator provided by the operator data source */
|
|
2712
|
+
external_id?: Maybe<Scalars["String"]>;
|
|
2723
2713
|
/** Name of an operator */
|
|
2724
2714
|
name?: Maybe<Scalars["String"]>;
|
|
2725
|
-
/** Ranking level on which the operator is placed or null in case the operator is not on any ranking level */
|
|
2726
|
-
ranking?: Maybe<Scalars["Int"]>;
|
|
2727
2715
|
/** Link to an operator’s website */
|
|
2728
2716
|
website?: Maybe<Scalars["String"]>;
|
|
2717
|
+
/** Image link to an operator’s logo */
|
|
2718
|
+
logo?: Maybe<OCPIImage>;
|
|
2719
|
+
/** Deprecated: Not used anymore, please use countries property instead */
|
|
2720
|
+
country?: Maybe<Scalars["String"]>;
|
|
2721
|
+
/** ISO-3166 alpha-2 country codes an operator is active in. */
|
|
2722
|
+
countries?: Maybe<Array<CountryCodeAlpha2>>;
|
|
2723
|
+
/** Contact information */
|
|
2724
|
+
contact?: Maybe<Contact>;
|
|
2725
|
+
/** Ranking level on which the operator is placed or null in case the operator is not on any ranking level */
|
|
2726
|
+
ranking?: Maybe<Scalars["Int"]>;
|
|
2727
|
+
/** Flag which indicates if the operator is in the excluded list */
|
|
2728
|
+
excluded?: Maybe<Scalars["Boolean"]>;
|
|
2729
2729
|
};
|
|
2730
2730
|
|
|
2731
2731
|
/** Filter which can be applied to retrieve the operator list action */
|
|
2732
2732
|
export type OperatorListFilter = {
|
|
2733
2733
|
/** ISO-3166 alpha-2 country codes an operator is active in. */
|
|
2734
2734
|
countries?: Maybe<Array<CountryCodeAlpha2>>;
|
|
2735
|
-
/** Only retrieve operators that are in the excluded list */
|
|
2736
|
-
excluded?: Maybe<Scalars["Boolean"]>;
|
|
2737
2735
|
/** List of ranking level(s) to be retrieved. Valid values are 1 to 10 */
|
|
2738
2736
|
ranking?: Maybe<Array<Scalars["Int"]>>;
|
|
2737
|
+
/** Only retrieve operators that are in the excluded list */
|
|
2738
|
+
excluded?: Maybe<Scalars["Boolean"]>;
|
|
2739
2739
|
};
|
|
2740
2740
|
|
|
2741
2741
|
/** Filter which can be applied to retrieve the operator list action */
|
|
2742
2742
|
export type OperatorListQuery = {
|
|
2743
|
-
/** Exact country code */
|
|
2744
|
-
country?: Maybe<Scalars["String"]>;
|
|
2745
|
-
/** External ID of an operator provided by an operator data source */
|
|
2746
|
-
external_id?: Maybe<Scalars["String"]>;
|
|
2747
2743
|
/** Unique operator ID */
|
|
2748
2744
|
id?: Maybe<Scalars["ID"]>;
|
|
2745
|
+
/** External ID of an operator provided by an operator data source */
|
|
2746
|
+
external_id?: Maybe<Scalars["String"]>;
|
|
2749
2747
|
/** Exact name */
|
|
2750
2748
|
name?: Maybe<Scalars["String"]>;
|
|
2749
|
+
/** Exact country code */
|
|
2750
|
+
country?: Maybe<Scalars["String"]>;
|
|
2751
2751
|
};
|
|
2752
2752
|
|
|
2753
2753
|
export enum ParkingCost {
|
|
@@ -2758,6 +2758,8 @@ export enum ParkingCost {
|
|
|
2758
2758
|
}
|
|
2759
2759
|
|
|
2760
2760
|
export type PathSegment = {
|
|
2761
|
+
/** Elevation (altitude) in meters */
|
|
2762
|
+
elevation?: Maybe<Scalars["Int"]>;
|
|
2761
2763
|
/** Average speed, in km/h, for this route path segment */
|
|
2762
2764
|
averageSpeed?: Maybe<Scalars["Float"]>;
|
|
2763
2765
|
/** Consumption, in kWh, of a route path segment */
|
|
@@ -2768,26 +2770,24 @@ export type PathSegment = {
|
|
|
2768
2770
|
distance?: Maybe<Scalars["Float"]>;
|
|
2769
2771
|
/** Duration, in seconds, of a route path segment */
|
|
2770
2772
|
duration?: Maybe<Scalars["Float"]>;
|
|
2771
|
-
/** Elevation (altitude) in meters */
|
|
2772
|
-
elevation?: Maybe<Scalars["Int"]>;
|
|
2773
2773
|
/** State of charge, in kWh, of a route path segment */
|
|
2774
2774
|
stateOfCharge?: Maybe<Scalars["Float"]>;
|
|
2775
2775
|
};
|
|
2776
2776
|
|
|
2777
2777
|
/** A GeoJSON Point */
|
|
2778
2778
|
export type Point = {
|
|
2779
|
-
/** The coordinates array with longitude as first value and latitude as second one */
|
|
2780
|
-
coordinates: Array<Scalars["Float"]>;
|
|
2781
2779
|
/** Point type */
|
|
2782
2780
|
type: PointType;
|
|
2781
|
+
/** The coordinates array with longitude as first value and latitude as second one */
|
|
2782
|
+
coordinates: Array<Scalars["Float"]>;
|
|
2783
2783
|
};
|
|
2784
2784
|
|
|
2785
2785
|
/** A GeoJSON Point input */
|
|
2786
2786
|
export type PointInput = {
|
|
2787
|
-
/** Coordinates [longitude, latitude] */
|
|
2788
|
-
coordinates: Array<Scalars["Float"]>;
|
|
2789
2787
|
/** Point type */
|
|
2790
2788
|
type: PointType;
|
|
2789
|
+
/** Coordinates [longitude, latitude] */
|
|
2790
|
+
coordinates: Array<Scalars["Float"]>;
|
|
2791
2791
|
};
|
|
2792
2792
|
|
|
2793
2793
|
/** GeoJSON Point type */
|
|
@@ -2797,10 +2797,10 @@ export enum PointType {
|
|
|
2797
2797
|
|
|
2798
2798
|
/** A GeoJSON Polygon */
|
|
2799
2799
|
export type Polygon = {
|
|
2800
|
-
/** List of coordinates representing a polygon */
|
|
2801
|
-
coordinates: Array<Maybe<Array<Maybe<Array<Maybe<Scalars["Float"]>>>>>>;
|
|
2802
2800
|
/** Polygon type */
|
|
2803
2801
|
type: PolygonType;
|
|
2802
|
+
/** List of coordinates representing a polygon */
|
|
2803
|
+
coordinates: Array<Maybe<Array<Maybe<Array<Maybe<Scalars["Float"]>>>>>>;
|
|
2804
2804
|
};
|
|
2805
2805
|
|
|
2806
2806
|
/** Polygon properties */
|
|
@@ -2824,22 +2824,22 @@ export type PowerList = {
|
|
|
2824
2824
|
|
|
2825
2825
|
/** Power stats model */
|
|
2826
2826
|
export type PowerStats = {
|
|
2827
|
-
/** The list of powers for the speed type */
|
|
2828
|
-
powers?: Maybe<Array<Maybe<PowerList>>>;
|
|
2829
2827
|
/** The charging speed type for the specified power */
|
|
2830
2828
|
type?: Maybe<StationSpeedType>;
|
|
2829
|
+
/** The list of powers for the speed type */
|
|
2830
|
+
powers?: Maybe<Array<Maybe<PowerList>>>;
|
|
2831
2831
|
};
|
|
2832
2832
|
|
|
2833
2833
|
/** The price model */
|
|
2834
2834
|
export type Price = {
|
|
2835
|
+
/** The value of the price */
|
|
2836
|
+
value?: Maybe<Scalars["String"]>;
|
|
2835
2837
|
/** The currency of the price */
|
|
2836
2838
|
currency?: Maybe<Scalars["String"]>;
|
|
2837
|
-
/** The value of the price which should be display by the frontend */
|
|
2838
|
-
displayValue?: Maybe<Scalars["String"]>;
|
|
2839
2839
|
/** The pricing model */
|
|
2840
2840
|
model?: Maybe<Scalars["String"]>;
|
|
2841
|
-
/** The value of the price */
|
|
2842
|
-
|
|
2841
|
+
/** The value of the price which should be display by the frontend */
|
|
2842
|
+
displayValue?: Maybe<Scalars["String"]>;
|
|
2843
2843
|
};
|
|
2844
2844
|
|
|
2845
2845
|
export type Pricing = {
|
|
@@ -2850,19 +2850,19 @@ export type Pricing = {
|
|
|
2850
2850
|
};
|
|
2851
2851
|
|
|
2852
2852
|
export type PricingList = {
|
|
2853
|
-
/** Price product elements */
|
|
2854
|
-
elements?: Maybe<Array<Maybe<PricingListElement>>>;
|
|
2855
2853
|
/** (MSP) Mobility Service Provider */
|
|
2856
2854
|
partner?: Maybe<Scalars["String"]>;
|
|
2857
2855
|
/** Product details */
|
|
2858
2856
|
product?: Maybe<PricingListProduct>;
|
|
2857
|
+
/** Price product elements */
|
|
2858
|
+
elements?: Maybe<Array<Maybe<PricingListElement>>>;
|
|
2859
2859
|
};
|
|
2860
2860
|
|
|
2861
2861
|
export type PricingListElement = {
|
|
2862
|
-
/** Price of the element type without VAT. */
|
|
2863
|
-
price_excl_vat?: Maybe<Scalars["Float"]>;
|
|
2864
2862
|
/** Price element type. */
|
|
2865
2863
|
type?: Maybe<PricingListElementType>;
|
|
2864
|
+
/** Price of the element type without VAT. */
|
|
2865
|
+
price_excl_vat?: Maybe<Scalars["Float"]>;
|
|
2866
2866
|
/** VAT percentage to apply */
|
|
2867
2867
|
vat?: Maybe<Scalars["Float"]>;
|
|
2868
2868
|
};
|
|
@@ -2872,23 +2872,23 @@ export enum PricingListElementType {
|
|
|
2872
2872
|
ENERGY = "ENERGY",
|
|
2873
2873
|
/** Starting price, fixed fee per charge session */
|
|
2874
2874
|
FLAT = "FLAT",
|
|
2875
|
-
/** Parking price per hour */
|
|
2876
|
-
PARKING_TIME = "PARKING_TIME",
|
|
2877
2875
|
/** Fixed price per hour */
|
|
2878
|
-
TIME = "TIME"
|
|
2876
|
+
TIME = "TIME",
|
|
2877
|
+
/** Parking price per hour */
|
|
2878
|
+
PARKING_TIME = "PARKING_TIME"
|
|
2879
2879
|
}
|
|
2880
2880
|
|
|
2881
2881
|
export type PricingListProduct = {
|
|
2882
|
-
/** Currency */
|
|
2883
|
-
currency?: Maybe<Scalars["String"]>;
|
|
2884
|
-
/** Description of the product */
|
|
2885
|
-
description?: Maybe<Scalars["String"]>;
|
|
2886
2882
|
/** Name of the payment card or subscription. If name is 'Adhoc price' the price is the CPO price */
|
|
2887
2883
|
name?: Maybe<Scalars["String"]>;
|
|
2888
|
-
/**
|
|
2889
|
-
|
|
2884
|
+
/** Description of the product */
|
|
2885
|
+
description?: Maybe<Scalars["String"]>;
|
|
2890
2886
|
/** Subscription type */
|
|
2891
2887
|
subscription_type?: Maybe<Scalars["String"]>;
|
|
2888
|
+
/** Subscription fee without VAT */
|
|
2889
|
+
subscription_fee_excl_vat?: Maybe<Scalars["Float"]>;
|
|
2890
|
+
/** Currency */
|
|
2891
|
+
currency?: Maybe<Scalars["String"]>;
|
|
2892
2892
|
};
|
|
2893
2893
|
|
|
2894
2894
|
export type Query = {
|
|
@@ -2896,42 +2896,44 @@ export type Query = {
|
|
|
2896
2896
|
amenityList?: Maybe<Array<Maybe<Amenity>>>;
|
|
2897
2897
|
/** Get information about a car by its ID */
|
|
2898
2898
|
car?: Maybe<Car>;
|
|
2899
|
-
/** Get a full list of cars */
|
|
2900
|
-
carList?: Maybe<Array<Maybe<CarList>>>;
|
|
2901
2899
|
/** Car premium data provides even more information about your car: tire pressure, prices, drivetrain data, and more. Please contact us for access to premium data. */
|
|
2902
2900
|
carPremium?: Maybe<CarPremium>;
|
|
2901
|
+
/** Get a full list of cars */
|
|
2902
|
+
carList?: Maybe<Array<Maybe<CarList>>>;
|
|
2903
2903
|
/** [BETA] Get an isoline by ID */
|
|
2904
2904
|
isoline?: Maybe<Isoline>;
|
|
2905
2905
|
/** [BETA] Get a navigation session by ID */
|
|
2906
2906
|
navigation?: Maybe<Navigation>;
|
|
2907
|
-
/** Get information about an operator by its ID */
|
|
2908
|
-
operator?: Maybe<Operator>;
|
|
2909
2907
|
/** Get a full list of operators */
|
|
2910
2908
|
operatorList?: Maybe<Array<Maybe<Operator>>>;
|
|
2909
|
+
/** Get information about an operator by its ID */
|
|
2910
|
+
operator?: Maybe<Operator>;
|
|
2911
2911
|
/** Get all reviews of a station by the station ID */
|
|
2912
2912
|
reviewList?: Maybe<Array<Review>>;
|
|
2913
|
+
/**
|
|
2914
|
+
* Get all reviews of stations that were added by an authenticated user.
|
|
2915
|
+
* The `x-token` header is mandatory in order to authorize the user who wants to retrieve all the reviews added by him/her.
|
|
2916
|
+
* This is a premium feature, contact Chargetrip for more information.
|
|
2917
|
+
*/
|
|
2918
|
+
userReviewList?: Maybe<Array<Review>>;
|
|
2913
2919
|
/** Get a route by ID */
|
|
2914
2920
|
route?: Maybe<Route>;
|
|
2915
2921
|
/** Retrieve information about a route path segment */
|
|
2916
2922
|
routePath?: Maybe<RoutePath>;
|
|
2923
|
+
/** Get the station statistics */
|
|
2924
|
+
stationStats?: Maybe<StationStats>;
|
|
2917
2925
|
/** Get information about a station by its ID */
|
|
2918
2926
|
station?: Maybe<Station>;
|
|
2919
|
-
/** Search for stations around a GeoJSON point with a specific distance in meters */
|
|
2920
|
-
stationAround?: Maybe<Array<Maybe<Station>>>;
|
|
2921
2927
|
/** Get a full list of stations */
|
|
2922
2928
|
stationList?: Maybe<Array<Maybe<Station>>>;
|
|
2923
|
-
/**
|
|
2924
|
-
|
|
2929
|
+
/** Search for stations around a GeoJSON point with a specific distance in meters */
|
|
2930
|
+
stationAround?: Maybe<Array<Maybe<Station>>>;
|
|
2925
2931
|
/** Get information about a tariff by the tariff ID */
|
|
2926
2932
|
tariff?: Maybe<OCPITariff>;
|
|
2927
2933
|
/** Get the full list of tariffs */
|
|
2928
2934
|
tariffList?: Maybe<Array<Maybe<OCPITariff>>>;
|
|
2929
|
-
/**
|
|
2930
|
-
|
|
2931
|
-
* The `x-token` header is mandatory in order to authorize the user who wants to retrieve all the reviews added by him/her.
|
|
2932
|
-
* This is a premium feature, contact Chargetrip for more information.
|
|
2933
|
-
*/
|
|
2934
|
-
userReviewList?: Maybe<Array<Review>>;
|
|
2935
|
+
/** Deprecated: This query will be removed in favor of navigation query and subscription. Mapping can be retrieved via the instructions field. */
|
|
2936
|
+
navigationMapping?: Maybe<Scalars["JSON"]>;
|
|
2935
2937
|
};
|
|
2936
2938
|
|
|
2937
2939
|
export type QueryamenityListArgs = {
|
|
@@ -2939,20 +2941,20 @@ export type QueryamenityListArgs = {
|
|
|
2939
2941
|
};
|
|
2940
2942
|
|
|
2941
2943
|
export type QuerycarArgs = {
|
|
2944
|
+
id?: Maybe<Scalars["ID"]>;
|
|
2942
2945
|
externalId?: Maybe<Scalars["Int"]>;
|
|
2946
|
+
};
|
|
2947
|
+
|
|
2948
|
+
export type QuerycarPremiumArgs = {
|
|
2943
2949
|
id?: Maybe<Scalars["ID"]>;
|
|
2944
2950
|
};
|
|
2945
2951
|
|
|
2946
2952
|
export type QuerycarListArgs = {
|
|
2947
|
-
filter?: Maybe<CarListFilter>;
|
|
2948
|
-
page?: Maybe<Scalars["Int"]>;
|
|
2949
2953
|
query?: Maybe<CarListQuery>;
|
|
2950
2954
|
search?: Maybe<Scalars["String"]>;
|
|
2955
|
+
filter?: Maybe<CarListFilter>;
|
|
2951
2956
|
size?: Maybe<Scalars["Int"]>;
|
|
2952
|
-
|
|
2953
|
-
|
|
2954
|
-
export type QuerycarPremiumArgs = {
|
|
2955
|
-
id?: Maybe<Scalars["ID"]>;
|
|
2957
|
+
page?: Maybe<Scalars["Int"]>;
|
|
2956
2958
|
};
|
|
2957
2959
|
|
|
2958
2960
|
export type QueryisolineArgs = {
|
|
@@ -2963,22 +2965,27 @@ export type QuerynavigationArgs = {
|
|
|
2963
2965
|
id: Scalars["ID"];
|
|
2964
2966
|
};
|
|
2965
2967
|
|
|
2966
|
-
export type QueryoperatorArgs = {
|
|
2967
|
-
id: Scalars["ID"];
|
|
2968
|
-
};
|
|
2969
|
-
|
|
2970
2968
|
export type QueryoperatorListArgs = {
|
|
2971
|
-
filter?: Maybe<OperatorListFilter>;
|
|
2972
|
-
page?: Maybe<Scalars["Int"]>;
|
|
2973
2969
|
query?: Maybe<OperatorListQuery>;
|
|
2974
2970
|
search?: Maybe<Scalars["String"]>;
|
|
2971
|
+
filter?: Maybe<OperatorListFilter>;
|
|
2975
2972
|
size?: Maybe<Scalars["Int"]>;
|
|
2973
|
+
page?: Maybe<Scalars["Int"]>;
|
|
2974
|
+
};
|
|
2975
|
+
|
|
2976
|
+
export type QueryoperatorArgs = {
|
|
2977
|
+
id: Scalars["ID"];
|
|
2976
2978
|
};
|
|
2977
2979
|
|
|
2978
2980
|
export type QueryreviewListArgs = {
|
|
2981
|
+
stationId: Scalars["ID"];
|
|
2982
|
+
size?: Maybe<Scalars["Int"]>;
|
|
2979
2983
|
page?: Maybe<Scalars["Int"]>;
|
|
2984
|
+
};
|
|
2985
|
+
|
|
2986
|
+
export type QueryuserReviewListArgs = {
|
|
2980
2987
|
size?: Maybe<Scalars["Int"]>;
|
|
2981
|
-
|
|
2988
|
+
page?: Maybe<Scalars["Int"]>;
|
|
2982
2989
|
};
|
|
2983
2990
|
|
|
2984
2991
|
export type QueryrouteArgs = {
|
|
@@ -2986,29 +2993,29 @@ export type QueryrouteArgs = {
|
|
|
2986
2993
|
};
|
|
2987
2994
|
|
|
2988
2995
|
export type QueryroutePathArgs = {
|
|
2989
|
-
alternativeId?: Maybe<Scalars["ID"]>;
|
|
2990
2996
|
id: Scalars["ID"];
|
|
2991
2997
|
location: PointInput;
|
|
2998
|
+
alternativeId?: Maybe<Scalars["ID"]>;
|
|
2992
2999
|
};
|
|
2993
3000
|
|
|
2994
3001
|
export type QuerystationArgs = {
|
|
2995
3002
|
id: Scalars["ID"];
|
|
2996
3003
|
};
|
|
2997
3004
|
|
|
2998
|
-
export type
|
|
2999
|
-
|
|
3000
|
-
|
|
3001
|
-
query?: Maybe<StationAroundQuery>;
|
|
3005
|
+
export type QuerystationListArgs = {
|
|
3006
|
+
query?: Maybe<StationListQuery>;
|
|
3007
|
+
filter?: Maybe<StationListFilter>;
|
|
3002
3008
|
search?: Maybe<Scalars["String"]>;
|
|
3003
3009
|
size?: Maybe<Scalars["Int"]>;
|
|
3010
|
+
page?: Maybe<Scalars["Int"]>;
|
|
3004
3011
|
};
|
|
3005
3012
|
|
|
3006
|
-
export type
|
|
3007
|
-
|
|
3008
|
-
|
|
3009
|
-
query?: Maybe<StationListQuery>;
|
|
3013
|
+
export type QuerystationAroundArgs = {
|
|
3014
|
+
query?: Maybe<StationAroundQuery>;
|
|
3015
|
+
filter?: Maybe<StationAroundFilter>;
|
|
3010
3016
|
search?: Maybe<Scalars["String"]>;
|
|
3011
3017
|
size?: Maybe<Scalars["Int"]>;
|
|
3018
|
+
page?: Maybe<Scalars["Int"]>;
|
|
3012
3019
|
};
|
|
3013
3020
|
|
|
3014
3021
|
export type QuerytariffArgs = {
|
|
@@ -3016,31 +3023,33 @@ export type QuerytariffArgs = {
|
|
|
3016
3023
|
};
|
|
3017
3024
|
|
|
3018
3025
|
export type QuerytariffListArgs = {
|
|
3019
|
-
page?: Maybe<Scalars["Int"]>;
|
|
3020
3026
|
size?: Maybe<Scalars["Int"]>;
|
|
3027
|
+
page?: Maybe<Scalars["Int"]>;
|
|
3021
3028
|
};
|
|
3022
3029
|
|
|
3023
|
-
export type
|
|
3024
|
-
|
|
3025
|
-
|
|
3030
|
+
export type QuerynavigationMappingArgs = {
|
|
3031
|
+
id: Scalars["ID"];
|
|
3032
|
+
provider: MappingProvider;
|
|
3033
|
+
precision?: Maybe<Scalars["Int"]>;
|
|
3034
|
+
language?: Maybe<MappingLanguage>;
|
|
3026
3035
|
};
|
|
3027
3036
|
|
|
3028
3037
|
/** EV specific data for a route request */
|
|
3029
3038
|
export type RequestEv = {
|
|
3030
|
-
/** Supported adapters of plugs for an EV */
|
|
3031
|
-
adapters?: Maybe<Array<Maybe<RequestEvPlug>>>;
|
|
3032
|
-
/** EV battery specific data */
|
|
3033
|
-
battery?: Maybe<RequestEvBattery>;
|
|
3034
|
-
/** Cargo weight, in kg */
|
|
3035
|
-
cargo?: Maybe<Scalars["Float"]>;
|
|
3036
|
-
/** Climate is on. The default is true */
|
|
3037
|
-
climate?: Maybe<Scalars["Boolean"]>;
|
|
3038
|
-
/** Consumption specific to an EV or inputed by a request */
|
|
3039
|
-
consumption?: Maybe<RequestEvConsumption>;
|
|
3040
3039
|
/** Internal ID of a Car */
|
|
3041
3040
|
id?: Maybe<Scalars["ID"]>;
|
|
3041
|
+
/** EV battery specific data */
|
|
3042
|
+
battery?: Maybe<RequestEvBattery>;
|
|
3043
|
+
/** Supported plugs for an EV */
|
|
3044
|
+
plugs?: Maybe<Array<Maybe<RequestEvPlug>>>;
|
|
3045
|
+
/** Supported adapters of plugs for an EV */
|
|
3046
|
+
adapters?: Maybe<Array<Maybe<RequestEvPlug>>>;
|
|
3042
3047
|
/** Minimum desired power of chargers */
|
|
3043
3048
|
minPower?: Maybe<Scalars["Int"]>;
|
|
3049
|
+
/** Climate is on. The default is true */
|
|
3050
|
+
climate?: Maybe<Scalars["Boolean"]>;
|
|
3051
|
+
/** Cargo weight, in kg */
|
|
3052
|
+
cargo?: Maybe<Scalars["Float"]>;
|
|
3044
3053
|
/**
|
|
3045
3054
|
* The number of passengers on board
|
|
3046
3055
|
* @deprecated In favor of occupants
|
|
@@ -3048,8 +3057,8 @@ export type RequestEv = {
|
|
|
3048
3057
|
numberOfPassengers?: Maybe<Scalars["Int"]>;
|
|
3049
3058
|
/** Number of occupants */
|
|
3050
3059
|
occupants?: Maybe<Scalars["Int"]>;
|
|
3051
|
-
/**
|
|
3052
|
-
|
|
3060
|
+
/** Consumption specific to an EV or inputed by a request */
|
|
3061
|
+
consumption?: Maybe<RequestEvConsumption>;
|
|
3053
3062
|
};
|
|
3054
3063
|
|
|
3055
3064
|
export type RequestEvBattery = {
|
|
@@ -3057,37 +3066,37 @@ export type RequestEvBattery = {
|
|
|
3057
3066
|
capacity?: Maybe<RequestEvBatteryValue>;
|
|
3058
3067
|
/** Usable capacity of a battery, in kWh. This value is computed from the provided capacity value */
|
|
3059
3068
|
capacityKwh?: Maybe<Scalars["Float"]>;
|
|
3060
|
-
/** Desired final amount of energy in a battery. If this is not filled in, it will be set to 20% of the car battery.usable_kwh */
|
|
3061
|
-
finalStateOfCharge?: Maybe<RequestEvBatteryValue>;
|
|
3062
|
-
/** Desired final amount of energy in a battery, in kWh. This value is computed from the provided final state of charge */
|
|
3063
|
-
finalStateOfChargeKwh?: Maybe<Scalars["Float"]>;
|
|
3064
3069
|
/** Current amount of energy in a battery. If this is not filled in, we assume the battery is full and it will be equal to the battery.usable_kwh */
|
|
3065
3070
|
stateOfCharge?: Maybe<RequestEvBatteryValue>;
|
|
3066
3071
|
/** Current amount of energy in a battery, in kWh. This value is computed from the provided state of charge */
|
|
3067
3072
|
stateOfChargeKwh?: Maybe<Scalars["Float"]>;
|
|
3073
|
+
/** Desired final amount of energy in a battery. If this is not filled in, it will be set to 20% of the car battery.usable_kwh */
|
|
3074
|
+
finalStateOfCharge?: Maybe<RequestEvBatteryValue>;
|
|
3075
|
+
/** Desired final amount of energy in a battery, in kWh. This value is computed from the provided final state of charge */
|
|
3076
|
+
finalStateOfChargeKwh?: Maybe<Scalars["Float"]>;
|
|
3068
3077
|
};
|
|
3069
3078
|
|
|
3070
3079
|
export type RequestEvBatteryInput = {
|
|
3071
3080
|
/** Usable capacity of a battery used to compute a route. We recommend you stay between 50% and 150%. If this in not filled in, we assume it is the same value as the car battery.usable_kwh */
|
|
3072
3081
|
capacity?: Maybe<RequestEvBatteryInputValue>;
|
|
3073
|
-
/** Desired final amount of energy in a battery. The value should be between 0 and 80% of the car battery.usable_kwh If this is not filled in, we assume it is 20% of the car battery.usable_kwh */
|
|
3074
|
-
finalStateOfCharge?: Maybe<RequestEvBatteryInputValue>;
|
|
3075
3082
|
/** Current amount of energy in a battery. If this is not filled in, we assume the battery is full and we fill it in with car battery.usable_kwh */
|
|
3076
3083
|
stateOfCharge?: Maybe<RequestEvBatteryInputValue>;
|
|
3084
|
+
/** Desired final amount of energy in a battery. The value should be between 0 and 80% of the car battery.usable_kwh If this is not filled in, we assume it is 20% of the car battery.usable_kwh */
|
|
3085
|
+
finalStateOfCharge?: Maybe<RequestEvBatteryInputValue>;
|
|
3077
3086
|
};
|
|
3078
3087
|
|
|
3079
3088
|
export type RequestEvBatteryInputValue = {
|
|
3080
|
-
/** Type of a desired final amount of energy in a battery */
|
|
3081
|
-
type: BatteryInputType;
|
|
3082
3089
|
/** Value of a desired final amount of energy in a battery */
|
|
3083
3090
|
value: Scalars["Float"];
|
|
3091
|
+
/** Type of a desired final amount of energy in a battery */
|
|
3092
|
+
type: BatteryInputType;
|
|
3084
3093
|
};
|
|
3085
3094
|
|
|
3086
3095
|
export type RequestEvBatteryValue = {
|
|
3087
|
-
/** Type of the desired final amount of energy in a battery */
|
|
3088
|
-
type: BatteryInputType;
|
|
3089
3096
|
/** Value of the desired final amount of energy in a battery */
|
|
3090
3097
|
value: Scalars["Float"];
|
|
3098
|
+
/** Type of the desired final amount of energy in a battery */
|
|
3099
|
+
type: BatteryInputType;
|
|
3091
3100
|
};
|
|
3092
3101
|
|
|
3093
3102
|
export type RequestEvConsumption = {
|
|
@@ -3109,42 +3118,42 @@ export type RequestEvConsumptionInput = {
|
|
|
3109
3118
|
};
|
|
3110
3119
|
|
|
3111
3120
|
export type RequestEvInput = {
|
|
3112
|
-
/** Supported adapters of plugs of an EV */
|
|
3113
|
-
adapters?: Maybe<Array<Maybe<RequestEvPlugInput>>>;
|
|
3114
|
-
/** Deprecated */
|
|
3115
|
-
auxConsumption?: Maybe<Scalars["Float"]>;
|
|
3116
|
-
/** The EV battery specific data */
|
|
3117
|
-
battery?: Maybe<RequestEvBatteryInput>;
|
|
3118
|
-
/** Deprecated */
|
|
3119
|
-
bmsConsumption?: Maybe<Scalars["Float"]>;
|
|
3120
|
-
/** Cargo weight, in kg */
|
|
3121
|
-
cargo?: Maybe<Scalars["Int"]>;
|
|
3122
|
-
/** Flag which indicates if the climate is on. The default is true */
|
|
3123
|
-
climate?: Maybe<Scalars["Boolean"]>;
|
|
3124
|
-
/** Consumption specific to the EV or inputted by the request */
|
|
3125
|
-
consumption?: Maybe<RequestEvConsumptionInput>;
|
|
3126
3121
|
/** Internal ID of a Car */
|
|
3127
3122
|
id: Scalars["ID"];
|
|
3123
|
+
/** The EV battery specific data */
|
|
3124
|
+
battery?: Maybe<RequestEvBatteryInput>;
|
|
3125
|
+
/** Supported plugs of an EV */
|
|
3126
|
+
plugs?: Maybe<Array<Maybe<RequestEvPlugInput>>>;
|
|
3127
|
+
/** Supported adapters of plugs of an EV */
|
|
3128
|
+
adapters?: Maybe<Array<Maybe<RequestEvPlugInput>>>;
|
|
3128
3129
|
/** Minimum desired power of chargers */
|
|
3129
3130
|
minPower?: Maybe<Scalars["Int"]>;
|
|
3131
|
+
/** Flag which indicates if the climate is on. The default is true */
|
|
3132
|
+
climate?: Maybe<Scalars["Boolean"]>;
|
|
3130
3133
|
/** Number of occupants */
|
|
3131
3134
|
occupants?: Maybe<Scalars["Int"]>;
|
|
3132
|
-
/**
|
|
3133
|
-
|
|
3135
|
+
/** Cargo weight, in kg */
|
|
3136
|
+
cargo?: Maybe<Scalars["Int"]>;
|
|
3137
|
+
/** Consumption specific to the EV or inputted by the request */
|
|
3138
|
+
consumption?: Maybe<RequestEvConsumptionInput>;
|
|
3139
|
+
/** Deprecated */
|
|
3140
|
+
auxConsumption?: Maybe<Scalars["Float"]>;
|
|
3141
|
+
/** Deprecated */
|
|
3142
|
+
bmsConsumption?: Maybe<Scalars["Float"]>;
|
|
3134
3143
|
};
|
|
3135
3144
|
|
|
3136
3145
|
export type RequestEvPlug = {
|
|
3137
|
-
/** Maximum charging speed for a plug */
|
|
3138
|
-
chargingPower?: Maybe<Scalars["Float"]>;
|
|
3139
3146
|
/** Type of the plug */
|
|
3140
3147
|
standard?: Maybe<ConnectorType>;
|
|
3148
|
+
/** Maximum charging speed for a plug */
|
|
3149
|
+
chargingPower?: Maybe<Scalars["Float"]>;
|
|
3141
3150
|
};
|
|
3142
3151
|
|
|
3143
3152
|
export type RequestEvPlugInput = {
|
|
3144
|
-
/** Maximum charging speed for this plug */
|
|
3145
|
-
chargingPower: Scalars["Float"];
|
|
3146
3153
|
/** Type of a plug */
|
|
3147
3154
|
standard: ConnectorType;
|
|
3155
|
+
/** Maximum charging speed for this plug */
|
|
3156
|
+
chargingPower: Scalars["Float"];
|
|
3148
3157
|
};
|
|
3149
3158
|
|
|
3150
3159
|
export type RequestInput = {
|
|
@@ -3157,68 +3166,68 @@ export type RequestInput = {
|
|
|
3157
3166
|
export type RequestRoute = {
|
|
3158
3167
|
/** Desired amenities near the stations, within a 1 km radius */
|
|
3159
3168
|
amenities?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
3160
|
-
/** Mode that indicates if we optimize the charging time or always charge to the maximum capacity */
|
|
3161
|
-
chargeMode?: Maybe<ChargeMode>;
|
|
3162
|
-
/** Destination of a route */
|
|
3163
|
-
destination?: Maybe<FeaturePoint>;
|
|
3164
|
-
/** Flag indicating wether the turn-by-turn navigation instructions should be prepared. Disclaimer: The functionality is under active development and the final API is a subject to change. Not ready for production */
|
|
3165
|
-
instructions?: Maybe<Scalars["Boolean"]>;
|
|
3166
3169
|
/**
|
|
3167
3170
|
* Requested operators
|
|
3168
3171
|
* @deprecated Will be removed. Use the operators property instead
|
|
3169
3172
|
*/
|
|
3170
3173
|
operatorIds?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
3171
3174
|
/**
|
|
3172
|
-
*
|
|
3175
|
+
* Preferred operators are required. In case there are no preferred operators the route cannot be calculated
|
|
3173
3176
|
* @deprecated Will be removed. Use the operators property instead
|
|
3174
3177
|
*/
|
|
3175
|
-
|
|
3178
|
+
operatorRequired?: Maybe<Scalars["Boolean"]>;
|
|
3176
3179
|
/**
|
|
3177
|
-
*
|
|
3180
|
+
* Encourage the route to use preferred operators. In case there are no preferred operators the route can still be calculated
|
|
3178
3181
|
* @deprecated Will be removed. Use the operators property instead
|
|
3179
3182
|
*/
|
|
3180
|
-
|
|
3183
|
+
operatorPrefer?: Maybe<Scalars["Boolean"]>;
|
|
3181
3184
|
/** Operator prioritization for a route */
|
|
3182
3185
|
operators?: Maybe<RouteOperators>;
|
|
3183
|
-
/** Origin of a route */
|
|
3184
|
-
origin?: Maybe<FeaturePoint>;
|
|
3185
|
-
/** 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% */
|
|
3186
|
-
safeRiskMargin?: Maybe<Scalars["Int"]>;
|
|
3187
3186
|
/** Season */
|
|
3188
3187
|
season?: Maybe<RouteSeason>;
|
|
3189
|
-
/**
|
|
3190
|
-
|
|
3188
|
+
/** 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% */
|
|
3189
|
+
safeRiskMargin?: Maybe<Scalars["Int"]>;
|
|
3190
|
+
/** Origin of a route */
|
|
3191
|
+
origin?: Maybe<FeaturePoint>;
|
|
3192
|
+
/** Destination of a route */
|
|
3193
|
+
destination?: Maybe<FeaturePoint>;
|
|
3191
3194
|
/** Locations where a route will stop */
|
|
3192
3195
|
via?: Maybe<Array<Maybe<FeaturePoint>>>;
|
|
3196
|
+
/** Radius in meters for alternative stations along a route (min 500 - max 5000) */
|
|
3197
|
+
stationsAlongRouteRadius?: Maybe<Scalars["Int"]>;
|
|
3198
|
+
/** Flag indicating wether the turn-by-turn navigation instructions should be prepared. Disclaimer: The functionality is under active development and the final API is a subject to change. Not ready for production */
|
|
3199
|
+
instructions?: Maybe<Scalars["Boolean"]>;
|
|
3200
|
+
/** Mode that indicates if we optimize the charging time or always charge to the maximum capacity */
|
|
3201
|
+
chargeMode?: Maybe<ChargeMode>;
|
|
3193
3202
|
};
|
|
3194
3203
|
|
|
3195
3204
|
export type RequestRouteInput = {
|
|
3196
3205
|
/** A list of desired amenities near the stations, with a 1 km radius */
|
|
3197
3206
|
amenities?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
3198
|
-
/** Mode that indicates if we optimize the charging time or always charge to the maximum capacity */
|
|
3199
|
-
chargeMode?: Maybe<ChargeMode>;
|
|
3200
|
-
/** Destination of a route */
|
|
3201
|
-
destination: FeaturePointInput;
|
|
3202
|
-
/** Deprecated: all routes will have turn-by-turn instructions prepared. Boolean will be ignored */
|
|
3203
|
-
instructions?: Maybe<Scalars["Boolean"]>;
|
|
3204
3207
|
/** Deprecated: in favor of operators. A list of requested operators */
|
|
3205
3208
|
operatorIds?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
3206
|
-
/** Deprecated: in favor of operators. Flag which indicates if the preferred operators should be loaded */
|
|
3207
|
-
operatorPrefer?: Maybe<Scalars["Boolean"]>;
|
|
3208
3209
|
/** Deprecated: in favor of operators. Flag which indicates if the operators are required */
|
|
3209
3210
|
operatorRequired?: Maybe<Scalars["Boolean"]>;
|
|
3211
|
+
/** Deprecated: in favor of operators. Flag which indicates if the preferred operators should be loaded */
|
|
3212
|
+
operatorPrefer?: Maybe<Scalars["Boolean"]>;
|
|
3210
3213
|
/** Operator prioritization for a route */
|
|
3211
3214
|
operators?: Maybe<RouteOperatorsInput>;
|
|
3212
|
-
/** Origin of a route */
|
|
3213
|
-
origin: FeaturePointInput;
|
|
3214
|
-
/** 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% */
|
|
3215
|
-
safeRiskMargin?: Maybe<Scalars["Int"]>;
|
|
3216
3215
|
/** Optional flag to specify the season */
|
|
3217
3216
|
season?: Maybe<RouteSeason>;
|
|
3218
|
-
/**
|
|
3219
|
-
|
|
3217
|
+
/** 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% */
|
|
3218
|
+
safeRiskMargin?: Maybe<Scalars["Int"]>;
|
|
3219
|
+
/** Mode that indicates if we optimize the charging time or always charge to the maximum capacity */
|
|
3220
|
+
chargeMode?: Maybe<ChargeMode>;
|
|
3221
|
+
/** Origin of a route */
|
|
3222
|
+
origin: FeaturePointInput;
|
|
3223
|
+
/** Destination of a route */
|
|
3224
|
+
destination: FeaturePointInput;
|
|
3220
3225
|
/** An optional list of locations where we should stop */
|
|
3221
3226
|
via?: Maybe<Array<Maybe<FeaturePointInput>>>;
|
|
3227
|
+
/** Alternative stations along a route within a specified radius in meters (minimum 500, maximum 5000) */
|
|
3228
|
+
stationsAlongRouteRadius?: Maybe<Scalars["Int"]>;
|
|
3229
|
+
/** Deprecated: all routes will have turn-by-turn instructions prepared. Boolean will be ignored */
|
|
3230
|
+
instructions?: Maybe<Scalars["Boolean"]>;
|
|
3222
3231
|
};
|
|
3223
3232
|
|
|
3224
3233
|
export type RequestUser = {
|
|
@@ -3228,195 +3237,195 @@ export type RequestUser = {
|
|
|
3228
3237
|
|
|
3229
3238
|
/** The review model */
|
|
3230
3239
|
export type Review = {
|
|
3231
|
-
/** Date and time when a review was created */
|
|
3232
|
-
createdAt?: Maybe<Scalars["String"]>;
|
|
3233
|
-
/** Car that was provided/selected by a user */
|
|
3234
|
-
ev?: Maybe<Car>;
|
|
3235
3240
|
/** ID of a review */
|
|
3236
3241
|
id: Scalars["ID"];
|
|
3237
|
-
/**
|
|
3238
|
-
|
|
3242
|
+
/** Station for which a review was provided */
|
|
3243
|
+
station?: Maybe<Station>;
|
|
3244
|
+
/** User who added a review. If a review was added by an anonymous user, this will be null */
|
|
3245
|
+
user?: Maybe<ReviewUser>;
|
|
3246
|
+
/** Rating of a review */
|
|
3247
|
+
rating?: Maybe<Scalars["Int"]>;
|
|
3239
3248
|
/** Message of a review */
|
|
3240
3249
|
message?: Maybe<Scalars["String"]>;
|
|
3250
|
+
/** Locale of a message */
|
|
3251
|
+
locale?: Maybe<Scalars["String"]>;
|
|
3252
|
+
/** Car that was provided/selected by a user */
|
|
3253
|
+
ev?: Maybe<Car>;
|
|
3241
3254
|
/** Plug type that was provided/selected by a user */
|
|
3242
3255
|
plugType?: Maybe<ConnectorType>;
|
|
3243
3256
|
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
3244
3257
|
properties?: Maybe<Scalars["JSON"]>;
|
|
3245
|
-
/** Rating of a review */
|
|
3246
|
-
rating?: Maybe<Scalars["Int"]>;
|
|
3247
|
-
/** Station for which a review was provided */
|
|
3248
|
-
station?: Maybe<Station>;
|
|
3249
3258
|
/** Boolean tags for a station review */
|
|
3250
3259
|
tags?: Maybe<ReviewTags>;
|
|
3260
|
+
/** Date and time when a review was created */
|
|
3261
|
+
createdAt?: Maybe<Scalars["String"]>;
|
|
3251
3262
|
/** Date and time when a review was updated */
|
|
3252
3263
|
updatedAt?: Maybe<Scalars["String"]>;
|
|
3253
|
-
/** User who added a review. If a review was added by an anonymous user, this will be null */
|
|
3254
|
-
user?: Maybe<ReviewUser>;
|
|
3255
3264
|
};
|
|
3256
3265
|
|
|
3257
3266
|
/** Form input to add a new review */
|
|
3258
3267
|
export type ReviewAdd = {
|
|
3259
|
-
/** ID
|
|
3260
|
-
|
|
3261
|
-
/**
|
|
3262
|
-
|
|
3268
|
+
/** Station ID for which a review is provided */
|
|
3269
|
+
stationId: Scalars["String"];
|
|
3270
|
+
/** Rating of a review */
|
|
3271
|
+
rating: Scalars["Int"];
|
|
3263
3272
|
/** Review message */
|
|
3264
3273
|
message?: Maybe<Scalars["String"]>;
|
|
3274
|
+
/** Locale of a message */
|
|
3275
|
+
locale?: Maybe<Scalars["String"]>;
|
|
3276
|
+
/** ID of the Car that was provided/selected by a user */
|
|
3277
|
+
ev?: Maybe<Scalars["String"]>;
|
|
3265
3278
|
/** Plug type that was provided/selected by a user */
|
|
3266
3279
|
plugType?: Maybe<ConnectorType>;
|
|
3267
3280
|
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
3268
3281
|
properties?: Maybe<Scalars["JSON"]>;
|
|
3269
|
-
/** Rating of a review */
|
|
3270
|
-
rating: Scalars["Int"];
|
|
3271
|
-
/** Station ID for which a review is provided */
|
|
3272
|
-
stationId: Scalars["String"];
|
|
3273
3282
|
/** Boolean tags for a station review */
|
|
3274
3283
|
tags?: Maybe<ReviewTagsInput>;
|
|
3275
3284
|
};
|
|
3276
3285
|
|
|
3277
3286
|
/** Form input for edit an existing review */
|
|
3278
3287
|
export type ReviewEdit = {
|
|
3279
|
-
/**
|
|
3280
|
-
|
|
3288
|
+
/** Rating of a review */
|
|
3289
|
+
rating: Scalars["Int"];
|
|
3281
3290
|
/** Review message */
|
|
3282
3291
|
message?: Maybe<Scalars["String"]>;
|
|
3292
|
+
/** Locale of a message */
|
|
3293
|
+
locale?: Maybe<Scalars["String"]>;
|
|
3283
3294
|
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
3284
3295
|
properties?: Maybe<Scalars["JSON"]>;
|
|
3285
|
-
/** Rating of a review */
|
|
3286
|
-
rating: Scalars["Int"];
|
|
3287
3296
|
/** Boolean tags for a station review */
|
|
3288
3297
|
tags?: Maybe<ReviewTagsInput>;
|
|
3289
3298
|
};
|
|
3290
3299
|
|
|
3291
3300
|
/** Statistical information for reviews of a station */
|
|
3292
3301
|
export type ReviewStats = {
|
|
3293
|
-
/** 'Total number of reviews */
|
|
3294
|
-
count?: Maybe<Scalars["Int"]>;
|
|
3295
3302
|
/** Average of all reviews */
|
|
3296
3303
|
rating?: Maybe<Scalars["Float"]>;
|
|
3304
|
+
/** 'Total number of reviews */
|
|
3305
|
+
count?: Maybe<Scalars["Int"]>;
|
|
3297
3306
|
};
|
|
3298
3307
|
|
|
3299
3308
|
/** Boolean tags for the station review */
|
|
3300
3309
|
export type ReviewTags = {
|
|
3301
|
-
/** Flag which indicates if the user recommended the station when the review was added */
|
|
3302
|
-
recommended?: Maybe<Scalars["Boolean"]>;
|
|
3303
3310
|
/** Flag which indicates if the station was working when the review was added */
|
|
3304
3311
|
working?: Maybe<Scalars["Boolean"]>;
|
|
3312
|
+
/** Flag which indicates if the user recommended the station when the review was added */
|
|
3313
|
+
recommended?: Maybe<Scalars["Boolean"]>;
|
|
3305
3314
|
};
|
|
3306
3315
|
|
|
3307
3316
|
/** Boolean tags for a station review */
|
|
3308
3317
|
export type ReviewTagsInput = {
|
|
3309
|
-
/** Flag which indicates if a user recommended a station when the review was added */
|
|
3310
|
-
recommended?: Maybe<Scalars["Boolean"]>;
|
|
3311
3318
|
/** Flag which indicates if a station was working when the review was added */
|
|
3312
3319
|
working?: Maybe<Scalars["Boolean"]>;
|
|
3320
|
+
/** Flag which indicates if a user recommended a station when the review was added */
|
|
3321
|
+
recommended?: Maybe<Scalars["Boolean"]>;
|
|
3313
3322
|
};
|
|
3314
3323
|
|
|
3315
3324
|
/** Special format for the user of a review */
|
|
3316
3325
|
export type ReviewUser = {
|
|
3317
|
-
/**
|
|
3318
|
-
|
|
3319
|
-
* @deprecated Please use name instead
|
|
3320
|
-
*/
|
|
3321
|
-
firstName?: Maybe<Scalars["String"]>;
|
|
3326
|
+
/** User full name. If a review was added by an anonymous user, this will be null */
|
|
3327
|
+
name?: Maybe<Scalars["String"]>;
|
|
3322
3328
|
/**
|
|
3323
3329
|
* User ID
|
|
3324
3330
|
* @deprecated Not sent back anymore, will be null
|
|
3325
3331
|
*/
|
|
3326
3332
|
id?: Maybe<Scalars["ID"]>;
|
|
3333
|
+
/**
|
|
3334
|
+
* First name
|
|
3335
|
+
* @deprecated Please use name instead
|
|
3336
|
+
*/
|
|
3337
|
+
firstName?: Maybe<Scalars["String"]>;
|
|
3327
3338
|
/**
|
|
3328
3339
|
* Last name
|
|
3329
3340
|
* @deprecated Please use name instead
|
|
3330
3341
|
*/
|
|
3331
3342
|
lastName?: Maybe<Scalars["String"]>;
|
|
3332
|
-
/** User full name. If a review was added by an anonymous user, this will be null */
|
|
3333
|
-
name?: Maybe<Scalars["String"]>;
|
|
3334
3343
|
};
|
|
3335
3344
|
|
|
3336
3345
|
export type Route = {
|
|
3346
|
+
/** Recommended route */
|
|
3347
|
+
route?: Maybe<RouteAlternative>;
|
|
3337
3348
|
/** Available alternatives */
|
|
3338
3349
|
alternatives?: Maybe<Array<Maybe<RouteAlternative>>>;
|
|
3339
|
-
/** Application who requested a route */
|
|
3340
|
-
app?: Maybe<RouteApp>;
|
|
3341
3350
|
/** EV specific data for a route request */
|
|
3342
3351
|
ev?: Maybe<RequestEv>;
|
|
3343
|
-
/**
|
|
3344
|
-
|
|
3352
|
+
/** @deprecated You will receive null values */
|
|
3353
|
+
user?: Maybe<RequestUser>;
|
|
3345
3354
|
/** Route request data */
|
|
3346
3355
|
routeRequest?: Maybe<RequestRoute>;
|
|
3356
|
+
/** Application who requested a route */
|
|
3357
|
+
app?: Maybe<RouteApp>;
|
|
3347
3358
|
/** Route status */
|
|
3348
3359
|
status?: Maybe<RouteStatus>;
|
|
3349
|
-
|
|
3350
|
-
|
|
3351
|
-
|
|
3352
|
-
|
|
3353
|
-
|
|
3354
|
-
/**
|
|
3355
|
-
|
|
3356
|
-
* @deprecated Will be removed in the future
|
|
3357
|
-
*/
|
|
3358
|
-
amenityRanking?: Maybe<Scalars["Int"]>;
|
|
3359
|
-
/** Total time required to charge for an entire route, in seconds */
|
|
3360
|
-
chargeTime?: Maybe<Scalars["Float"]>;
|
|
3360
|
+
};
|
|
3361
|
+
|
|
3362
|
+
export type RouteAlternative = {
|
|
3363
|
+
/** ID of a route alternative */
|
|
3364
|
+
id?: Maybe<Scalars["ID"]>;
|
|
3365
|
+
/** Type of alternative route */
|
|
3366
|
+
type?: Maybe<RouteAlternativeType>;
|
|
3361
3367
|
/** Number of charges along a route */
|
|
3362
3368
|
charges?: Maybe<Scalars["Int"]>;
|
|
3363
3369
|
/** Number of available charges along a route */
|
|
3364
3370
|
chargesAvailable?: Maybe<Scalars["Int"]>;
|
|
3365
3371
|
/** Number of occupied charges along a route */
|
|
3366
3372
|
chargesOccupied?: Maybe<Scalars["Int"]>;
|
|
3367
|
-
/** Number of out of order charges along a route */
|
|
3368
|
-
chargesOutOfOrder?: Maybe<Scalars["Int"]>;
|
|
3369
3373
|
/** Number of unknown charges along a route */
|
|
3370
3374
|
chargesUnknown?: Maybe<Scalars["Int"]>;
|
|
3371
|
-
/**
|
|
3372
|
-
|
|
3375
|
+
/** Number of out of order charges along a route */
|
|
3376
|
+
chargesOutOfOrder?: Maybe<Scalars["Int"]>;
|
|
3373
3377
|
/** Total distance of a route in meters */
|
|
3374
3378
|
distance?: Maybe<Scalars["Int"]>;
|
|
3375
3379
|
/** Total duration of a route, including charge time, in seconds */
|
|
3376
3380
|
duration?: Maybe<Scalars["Int"]>;
|
|
3377
|
-
/** Total
|
|
3378
|
-
|
|
3379
|
-
/**
|
|
3380
|
-
|
|
3381
|
+
/** Total energy used for a route in kWh */
|
|
3382
|
+
consumption?: Maybe<Scalars["Float"]>;
|
|
3383
|
+
/** Total time required to charge for an entire route, in seconds */
|
|
3384
|
+
chargeTime?: Maybe<Scalars["Float"]>;
|
|
3381
3385
|
/**
|
|
3382
|
-
*
|
|
3383
|
-
* @deprecated Will be removed in the future
|
|
3386
|
+
* Amenity ranking for an alternative
|
|
3387
|
+
* @deprecated Will be removed in the future
|
|
3384
3388
|
*/
|
|
3385
|
-
|
|
3386
|
-
/** Total number of meters which are going up on a route */
|
|
3387
|
-
elevationUp?: Maybe<Scalars["Float"]>;
|
|
3388
|
-
/** ID of a route alternative */
|
|
3389
|
-
id?: Maybe<Scalars["ID"]>;
|
|
3390
|
-
/** List of raw turn-by-turn navigation instructions */
|
|
3391
|
-
instructions?: Maybe<Array<Maybe<RouteInstruction>>>;
|
|
3392
|
-
/** Legs of the route */
|
|
3393
|
-
legs?: Maybe<Array<Maybe<RouteLeg>>>;
|
|
3394
|
-
/** Path elevation, distance, duration, consumption and speed values, grouped into 100 segments */
|
|
3395
|
-
pathPlot?: Maybe<Array<Maybe<PathSegment>>>;
|
|
3396
|
-
/** Polyline containing encoded coordinates */
|
|
3397
|
-
polyline?: Maybe<Scalars["String"]>;
|
|
3398
|
-
/** Remaining range, in meters, at the end of a trip */
|
|
3399
|
-
rangeEnd?: Maybe<Scalars["Int"]>;
|
|
3400
|
-
/** Remaining range, energy in kWh, at the end of a trip */
|
|
3401
|
-
rangeEndKwh?: Maybe<Scalars["Float"]>;
|
|
3402
|
-
/** Remaining range, energy in percentage, at the end of a trip */
|
|
3403
|
-
rangeEndPercentage?: Maybe<Scalars["Int"]>;
|
|
3389
|
+
amenityRanking?: Maybe<Scalars["Int"]>;
|
|
3404
3390
|
/** Range, in meters, available at the beginning of a trip */
|
|
3405
3391
|
rangeStart?: Maybe<Scalars["Int"]>;
|
|
3406
3392
|
/** Total energy in a battery at the beginning of a trip, in kWh */
|
|
3407
3393
|
rangeStartKwh?: Maybe<Scalars["Float"]>;
|
|
3408
3394
|
/** Total energy in a battery at the beginning of a trip, in percentage */
|
|
3409
3395
|
rangeStartPercentage?: Maybe<Scalars["Int"]>;
|
|
3396
|
+
/** Remaining range, in meters, at the end of a trip */
|
|
3397
|
+
rangeEnd?: Maybe<Scalars["Int"]>;
|
|
3398
|
+
/** Remaining range, energy in kWh, at the end of a trip */
|
|
3399
|
+
rangeEndKwh?: Maybe<Scalars["Float"]>;
|
|
3400
|
+
/** Remaining range, energy in percentage, at the end of a trip */
|
|
3401
|
+
rangeEndPercentage?: Maybe<Scalars["Int"]>;
|
|
3402
|
+
/** Text information about a route direction */
|
|
3403
|
+
via?: Maybe<Scalars["String"]>;
|
|
3404
|
+
/** Polyline containing encoded coordinates */
|
|
3405
|
+
polyline?: Maybe<Scalars["String"]>;
|
|
3406
|
+
/** Path elevation, distance, duration, consumption and speed values, grouped into 100 segments */
|
|
3407
|
+
pathPlot?: Maybe<Array<Maybe<PathSegment>>>;
|
|
3408
|
+
/**
|
|
3409
|
+
* Elevation values. Each elevationPlot has a hundred points, independent of the length of a route
|
|
3410
|
+
* @deprecated Will be removed in the future; Use the pathPlot property
|
|
3411
|
+
*/
|
|
3412
|
+
elevationPlot?: Maybe<Array<Maybe<Scalars["Float"]>>>;
|
|
3413
|
+
/** Total number of meters which are going up on a route */
|
|
3414
|
+
elevationUp?: Maybe<Scalars["Float"]>;
|
|
3415
|
+
/** Total number of meters which are going down on a route */
|
|
3416
|
+
elevationDown?: Maybe<Scalars["Float"]>;
|
|
3417
|
+
/** Highest value from the elevation array */
|
|
3418
|
+
elevationMax?: Maybe<Scalars["Float"]>;
|
|
3410
3419
|
/** Money and CO2 saving information */
|
|
3411
3420
|
saving?: Maybe<RouteAlternativeSaving>;
|
|
3421
|
+
/** Legs of the route */
|
|
3422
|
+
legs?: Maybe<Array<Maybe<RouteLeg>>>;
|
|
3423
|
+
/** List of raw turn-by-turn navigation instructions */
|
|
3424
|
+
instructions?: Maybe<Array<Maybe<RouteInstruction>>>;
|
|
3412
3425
|
/** Alternative stations along a route within specified radius in meters. Only if it was provided at newRoute mutation */
|
|
3413
3426
|
stationsAlongRoute?: Maybe<Array<Maybe<RouteStationsAlong>>>;
|
|
3414
3427
|
/** Tags of a route alternative. Values: road, highway, toll, ferry, etc. */
|
|
3415
3428
|
tags?: Maybe<Array<Maybe<RouteTagType>>>;
|
|
3416
|
-
/** Type of alternative route */
|
|
3417
|
-
type?: Maybe<RouteAlternativeType>;
|
|
3418
|
-
/** Text information about a route direction */
|
|
3419
|
-
via?: Maybe<Scalars["String"]>;
|
|
3420
3429
|
};
|
|
3421
3430
|
|
|
3422
3431
|
export type RouteAlternativepolylineArgs = {
|
|
@@ -3424,26 +3433,26 @@ export type RouteAlternativepolylineArgs = {
|
|
|
3424
3433
|
};
|
|
3425
3434
|
|
|
3426
3435
|
export type RouteAlternativeSaving = {
|
|
3427
|
-
/** Average energy price with which the calculation was made */
|
|
3428
|
-
averageEnergyPrice?: Maybe<Scalars["String"]>;
|
|
3429
|
-
/** Average gas price with which the calculation was made */
|
|
3430
|
-
averageGasPrice?: Maybe<Scalars["String"]>;
|
|
3431
3436
|
/** Total amount of CO2, in grams, which would be used with a petrol vehicle */
|
|
3432
3437
|
co2?: Maybe<Scalars["String"]>;
|
|
3433
|
-
/** Currency */
|
|
3434
|
-
currency?: Maybe<Scalars["String"]>;
|
|
3435
3438
|
/** Money saved by a user driving this route with the electric vehicle */
|
|
3436
3439
|
money?: Maybe<Scalars["String"]>;
|
|
3440
|
+
/** Currency */
|
|
3441
|
+
currency?: Maybe<Scalars["String"]>;
|
|
3442
|
+
/** Average gas price with which the calculation was made */
|
|
3443
|
+
averageGasPrice?: Maybe<Scalars["String"]>;
|
|
3444
|
+
/** Average energy price with which the calculation was made */
|
|
3445
|
+
averageEnergyPrice?: Maybe<Scalars["String"]>;
|
|
3437
3446
|
};
|
|
3438
3447
|
|
|
3439
3448
|
/** Types of an alternative route */
|
|
3440
3449
|
export enum RouteAlternativeType {
|
|
3441
|
-
/**
|
|
3442
|
-
|
|
3450
|
+
/** Fastest route between origin and destination */
|
|
3451
|
+
FASTEST = "fastest",
|
|
3443
3452
|
/** Best matching route based on operator and amenities preferences */
|
|
3444
3453
|
BESTMATCHING = "bestMatching",
|
|
3445
|
-
/**
|
|
3446
|
-
|
|
3454
|
+
/** An alternative to the fastest route */
|
|
3455
|
+
ALTERNATIVE = "alternative"
|
|
3447
3456
|
}
|
|
3448
3457
|
|
|
3449
3458
|
export type RouteApp = {
|
|
@@ -3452,118 +3461,118 @@ export type RouteApp = {
|
|
|
3452
3461
|
};
|
|
3453
3462
|
|
|
3454
3463
|
export type RouteInstruction = {
|
|
3455
|
-
/** Distance, in meters, of the current route instruction */
|
|
3456
|
-
distance?: Maybe<Scalars["Int"]>;
|
|
3457
|
-
/** Exit number on a roundabout. This field exists only on sign `USE_ROUNDABOUT` (6), otherwise is null */
|
|
3458
|
-
exit_number?: Maybe<Scalars["Int"]>;
|
|
3459
|
-
/** Name of the street on which the instruction is */
|
|
3460
|
-
name?: Maybe<Scalars["String"]>;
|
|
3461
3464
|
/** Information about the points on the polyline */
|
|
3462
3465
|
points?: Maybe<RouteInstructionPoints>;
|
|
3463
3466
|
/** Sign of the instruction. See `RouteInstructionSign` */
|
|
3464
3467
|
sign?: Maybe<RouteInstructionSign>;
|
|
3468
|
+
/** Name of the street on which the instruction is */
|
|
3469
|
+
name?: Maybe<Scalars["String"]>;
|
|
3470
|
+
/** Distance, in meters, of the current route instruction */
|
|
3471
|
+
distance?: Maybe<Scalars["Int"]>;
|
|
3465
3472
|
/** Duration, in seconds, of the current route instruction */
|
|
3466
3473
|
time?: Maybe<Scalars["Int"]>;
|
|
3474
|
+
/** Exit number on a roundabout. This field exists only on sign `USE_ROUNDABOUT` (6), otherwise is null */
|
|
3475
|
+
exit_number?: Maybe<Scalars["Int"]>;
|
|
3467
3476
|
/** Curvature angle between the roundabout and street you exit the roundabout. This field exists only on sign USE_ROUNDABOUT (6), otherwise is null */
|
|
3468
3477
|
turn_angle?: Maybe<Scalars["Float"]>;
|
|
3469
3478
|
};
|
|
3470
3479
|
|
|
3471
3480
|
export type RouteInstructionPoints = {
|
|
3472
|
-
/** The 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 */
|
|
3473
|
-
interval?: Maybe<Array<Maybe<Scalars["Int"]>>>;
|
|
3474
3481
|
/** Number of polyline points which are included in this instruction */
|
|
3475
3482
|
size?: Maybe<Scalars["Int"]>;
|
|
3483
|
+
/** The 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 */
|
|
3484
|
+
interval?: Maybe<Array<Maybe<Scalars["Int"]>>>;
|
|
3476
3485
|
};
|
|
3477
3486
|
|
|
3478
3487
|
/** Sign belonging to the instruction indicating the main maneuver */
|
|
3479
3488
|
export enum RouteInstructionSign {
|
|
3480
|
-
|
|
3481
|
-
|
|
3482
|
-
|
|
3489
|
+
UNKNOWN = "UNKNOWN",
|
|
3490
|
+
U_TURN_UNKNOWN = "U_TURN_UNKNOWN",
|
|
3491
|
+
U_TURN_LEFT = "U_TURN_LEFT",
|
|
3483
3492
|
KEEP_LEFT = "KEEP_LEFT",
|
|
3484
|
-
KEEP_RIGHT = "KEEP_RIGHT",
|
|
3485
3493
|
LEAVE_ROUNDABOUT = "LEAVE_ROUNDABOUT",
|
|
3486
|
-
PT_END_TRIP = "PT_END_TRIP",
|
|
3487
|
-
PT_START_TRIP = "PT_START_TRIP",
|
|
3488
|
-
PT_TRANSFER = "PT_TRANSFER",
|
|
3489
|
-
REACHED_CHARGING_STATION = "REACHED_CHARGING_STATION",
|
|
3490
|
-
REACHED_VIA = "REACHED_VIA",
|
|
3491
|
-
TURN_LEFT = "TURN_LEFT",
|
|
3492
|
-
TURN_RIGHT = "TURN_RIGHT",
|
|
3493
3494
|
TURN_SHARP_LEFT = "TURN_SHARP_LEFT",
|
|
3494
|
-
|
|
3495
|
+
TURN_LEFT = "TURN_LEFT",
|
|
3495
3496
|
TURN_SLIGHT_LEFT = "TURN_SLIGHT_LEFT",
|
|
3497
|
+
CONTINUE_ON_STREET = "CONTINUE_ON_STREET",
|
|
3496
3498
|
TURN_SLIGHT_RIGHT = "TURN_SLIGHT_RIGHT",
|
|
3497
|
-
|
|
3499
|
+
TURN_RIGHT = "TURN_RIGHT",
|
|
3500
|
+
TURN_SHARP_RIGHT = "TURN_SHARP_RIGHT",
|
|
3501
|
+
FINISH = "FINISH",
|
|
3502
|
+
REACHED_VIA = "REACHED_VIA",
|
|
3503
|
+
REACHED_CHARGING_STATION = "REACHED_CHARGING_STATION",
|
|
3498
3504
|
USE_ROUNDABOUT = "USE_ROUNDABOUT",
|
|
3499
|
-
|
|
3505
|
+
KEEP_RIGHT = "KEEP_RIGHT",
|
|
3500
3506
|
U_TURN_RIGHT = "U_TURN_RIGHT",
|
|
3501
|
-
|
|
3507
|
+
PT_START_TRIP = "PT_START_TRIP",
|
|
3508
|
+
PT_TRANSFER = "PT_TRANSFER",
|
|
3509
|
+
PT_END_TRIP = "PT_END_TRIP",
|
|
3510
|
+
IGNORE = "IGNORE"
|
|
3502
3511
|
}
|
|
3503
3512
|
|
|
3504
3513
|
export type RouteLeg = {
|
|
3505
|
-
/**
|
|
3506
|
-
|
|
3507
|
-
/** Total time required to charge a battery until 80%, in seconds */
|
|
3508
|
-
chargeTime?: Maybe<Scalars["Int"]>;
|
|
3509
|
-
/** Recommended connector for charging */
|
|
3510
|
-
connector?: Maybe<Connector>;
|
|
3511
|
-
/** Total energy used in a leg in kWh */
|
|
3512
|
-
consumption?: Maybe<Scalars["Float"]>;
|
|
3513
|
-
/** Destination point location */
|
|
3514
|
-
destination?: Maybe<FeaturePoint>;
|
|
3514
|
+
/** ID of a leg */
|
|
3515
|
+
id?: Maybe<Scalars["ID"]>;
|
|
3515
3516
|
/** Distance from the start to the end of a leg, in meters */
|
|
3516
3517
|
distance?: Maybe<Scalars["Int"]>;
|
|
3517
3518
|
/** Total drive time from the start to the end of a leg, in seconds */
|
|
3518
3519
|
duration?: Maybe<Scalars["Int"]>;
|
|
3519
|
-
/**
|
|
3520
|
-
|
|
3521
|
-
/**
|
|
3522
|
-
|
|
3520
|
+
/** Total energy used in a leg in kWh */
|
|
3521
|
+
consumption?: Maybe<Scalars["Float"]>;
|
|
3522
|
+
/** Range, in meters, available at the beginning of a leg */
|
|
3523
|
+
rangeStart?: Maybe<Scalars["Int"]>;
|
|
3524
|
+
/** Total energy in a battery at the beginning of a leg, in kWh */
|
|
3525
|
+
rangeStartKwh?: Maybe<Scalars["Float"]>;
|
|
3526
|
+
/** Total energy in a battery at the beginning of a trip, in percentage */
|
|
3527
|
+
rangeStartPercentage?: Maybe<Scalars["Int"]>;
|
|
3528
|
+
/** Range, in meters, available at the end of a leg */
|
|
3529
|
+
rangeEnd?: Maybe<Scalars["Int"]>;
|
|
3530
|
+
/** Total energy left in a battery at the end of a leg, in kWh */
|
|
3531
|
+
rangeEndKwh?: Maybe<Scalars["Float"]>;
|
|
3532
|
+
/** Remaining range, energy in percentage, at the end of a trip */
|
|
3533
|
+
rangeEndPercentage?: Maybe<Scalars["Int"]>;
|
|
3534
|
+
/** Origin point location */
|
|
3535
|
+
origin?: Maybe<FeaturePoint>;
|
|
3536
|
+
/** Destination point location */
|
|
3537
|
+
destination?: Maybe<FeaturePoint>;
|
|
3538
|
+
/** Type of a leg */
|
|
3539
|
+
type?: Maybe<LegType>;
|
|
3523
3540
|
/** 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 */
|
|
3524
3541
|
name?: Maybe<Scalars["String"]>;
|
|
3525
|
-
/**
|
|
3526
|
-
|
|
3542
|
+
/** ID of a station */
|
|
3543
|
+
stationId?: Maybe<Scalars["String"]>;
|
|
3527
3544
|
/** ID of an operator */
|
|
3528
3545
|
operatorId?: Maybe<Scalars["String"]>;
|
|
3529
3546
|
/** Name of an operator */
|
|
3530
3547
|
operatorName?: Maybe<Scalars["String"]>;
|
|
3531
3548
|
/** Ranking of an operator */
|
|
3532
3549
|
operatorRanking?: Maybe<Scalars["Int"]>;
|
|
3533
|
-
/**
|
|
3534
|
-
|
|
3550
|
+
/** Total time required to charge a battery until 80%, in seconds */
|
|
3551
|
+
chargeTime?: Maybe<Scalars["Int"]>;
|
|
3552
|
+
/** Recommended EVSE where to charge */
|
|
3553
|
+
evse?: Maybe<EVSE>;
|
|
3554
|
+
/** Recommended connector for charging */
|
|
3555
|
+
connector?: Maybe<Connector>;
|
|
3535
3556
|
/** Number of compatible plugs available at a charge station */
|
|
3536
3557
|
plugsAvailable?: Maybe<Scalars["Int"]>;
|
|
3537
|
-
/** Total number of compatible plugs at a charge station */
|
|
3538
|
-
plugsCount?: Maybe<Scalars["Int"]>;
|
|
3539
3558
|
/** Number of compatible plugs occupied at a charge station */
|
|
3540
3559
|
plugsOccupied?: Maybe<Scalars["Int"]>;
|
|
3541
|
-
/** Number of compatible plugs out of order at a charge station */
|
|
3542
|
-
plugsOutOfOrder?: Maybe<Scalars["Int"]>;
|
|
3543
3560
|
/** Number of compatible plugs unknown at a charge station */
|
|
3544
3561
|
plugsUnknown?: Maybe<Scalars["Int"]>;
|
|
3562
|
+
/** Number of compatible plugs out of order at a charge station */
|
|
3563
|
+
plugsOutOfOrder?: Maybe<Scalars["Int"]>;
|
|
3564
|
+
/** Total number of compatible plugs at a charge station */
|
|
3565
|
+
plugsCount?: Maybe<Scalars["Int"]>;
|
|
3545
3566
|
/** Polyline containing encoded coordinates */
|
|
3546
3567
|
polyline?: Maybe<Scalars["String"]>;
|
|
3547
|
-
/** Range, in meters, available at the end of a leg */
|
|
3548
|
-
rangeEnd?: Maybe<Scalars["Int"]>;
|
|
3549
|
-
/** Total energy left in a battery at the end of a leg, in kWh */
|
|
3550
|
-
rangeEndKwh?: Maybe<Scalars["Float"]>;
|
|
3551
|
-
/** Remaining range, energy in percentage, at the end of a trip */
|
|
3552
|
-
rangeEndPercentage?: Maybe<Scalars["Int"]>;
|
|
3553
|
-
/** Range, in meters, available at the beginning of a leg */
|
|
3554
|
-
rangeStart?: Maybe<Scalars["Int"]>;
|
|
3555
|
-
/** Total energy in a battery at the beginning of a leg, in kWh */
|
|
3556
|
-
rangeStartKwh?: Maybe<Scalars["Float"]>;
|
|
3557
|
-
/** Total energy in a battery at the beginning of a trip, in percentage */
|
|
3558
|
-
rangeStartPercentage?: Maybe<Scalars["Int"]>;
|
|
3559
|
-
/** ID of a station */
|
|
3560
|
-
stationId?: Maybe<Scalars["String"]>;
|
|
3561
3568
|
/** Steps of a leg */
|
|
3562
3569
|
steps?: Maybe<Array<Maybe<RouteStep>>>;
|
|
3563
3570
|
/** Tags of a leg. Values: road, highway, toll, ferry */
|
|
3564
3571
|
tags?: Maybe<Array<Maybe<RouteTagType>>>;
|
|
3565
|
-
/**
|
|
3566
|
-
|
|
3572
|
+
/** Cargo weight in a vehicle for the duration of a leg, in kg */
|
|
3573
|
+
cargo?: Maybe<Scalars["Float"]>;
|
|
3574
|
+
/** Number of occupants in a vehicle for the duration of a leg */
|
|
3575
|
+
occupants?: Maybe<Scalars["Int"]>;
|
|
3567
3576
|
};
|
|
3568
3577
|
|
|
3569
3578
|
export type RouteLegpolylineArgs = {
|
|
@@ -3572,22 +3581,22 @@ export type RouteLegpolylineArgs = {
|
|
|
3572
3581
|
|
|
3573
3582
|
/** Prioritized operators for a route calculation */
|
|
3574
3583
|
export type RouteOperators = {
|
|
3575
|
-
/** Operator IDs which should be excluded from a route */
|
|
3576
|
-
exclude?: Maybe<Array<Maybe<Scalars["ID"]>>>;
|
|
3577
|
-
/** Ranking of an operator with multiple levels, each level having it's own penalty value */
|
|
3578
|
-
ranking?: Maybe<RouteOperatorsRanking>;
|
|
3579
3584
|
/** Flag indicating if the operators ranking should be preferred or required */
|
|
3580
3585
|
type?: Maybe<RouteOperatorsType>;
|
|
3586
|
+
/** Ranking of an operator with multiple levels, each level having it's own penalty value */
|
|
3587
|
+
ranking?: Maybe<RouteOperatorsRanking>;
|
|
3588
|
+
/** Operator IDs which should be excluded from a route */
|
|
3589
|
+
exclude?: Maybe<Array<Maybe<Scalars["ID"]>>>;
|
|
3581
3590
|
};
|
|
3582
3591
|
|
|
3583
3592
|
/** Prioritized operators for a route calculation */
|
|
3584
3593
|
export type RouteOperatorsInput = {
|
|
3585
|
-
/** Operator IDs which should be excluded from a route */
|
|
3586
|
-
exclude?: Maybe<Array<Maybe<Scalars["ID"]>>>;
|
|
3587
|
-
/** Ranking of an operator with multiple levels, each level having it's own penalty value */
|
|
3588
|
-
ranking?: Maybe<RouteOperatorsRankingInput>;
|
|
3589
3594
|
/** Flag indicating if the operators ranking should be preferred or required */
|
|
3590
3595
|
type?: Maybe<RouteOperatorsType>;
|
|
3596
|
+
/** Ranking of an operator with multiple levels, each level having it's own penalty value */
|
|
3597
|
+
ranking?: Maybe<RouteOperatorsRankingInput>;
|
|
3598
|
+
/** Operator IDs which should be excluded from a route */
|
|
3599
|
+
exclude?: Maybe<Array<Maybe<Scalars["ID"]>>>;
|
|
3591
3600
|
};
|
|
3592
3601
|
|
|
3593
3602
|
/** Ranking configuration for prioritized operators */
|
|
@@ -3649,8 +3658,14 @@ export enum RouteOperatorsType {
|
|
|
3649
3658
|
}
|
|
3650
3659
|
|
|
3651
3660
|
export type RoutePath = {
|
|
3661
|
+
/** GeoJSON location of a route path segment */
|
|
3662
|
+
location?: Maybe<Point>;
|
|
3663
|
+
/** Elevation (altitude) in meters */
|
|
3664
|
+
elevation?: Maybe<Scalars["Int"]>;
|
|
3652
3665
|
/** Average speed, in km/h, for this route path segment */
|
|
3653
3666
|
averageSpeed?: Maybe<Scalars["Float"]>;
|
|
3667
|
+
/** Recommended speed, in km/h for this route path segment to optimise the consumption */
|
|
3668
|
+
recommendedSpeed?: Maybe<Scalars["Float"]>;
|
|
3654
3669
|
/** Consumption, in kWh, of a route path segment */
|
|
3655
3670
|
consumption?: Maybe<Scalars["Float"]>;
|
|
3656
3671
|
/** Consumption, in kWh per km, of a route path segment */
|
|
@@ -3659,68 +3674,62 @@ export type RoutePath = {
|
|
|
3659
3674
|
distance?: Maybe<Scalars["Float"]>;
|
|
3660
3675
|
/** Duration, in seconds, of a route path segment */
|
|
3661
3676
|
duration?: Maybe<Scalars["Float"]>;
|
|
3662
|
-
/** Elevation (altitude) in meters */
|
|
3663
|
-
elevation?: Maybe<Scalars["Int"]>;
|
|
3664
|
-
/** GeoJSON location of a route path segment */
|
|
3665
|
-
location?: Maybe<Point>;
|
|
3666
|
-
/** Recommended speed, in km/h for this route path segment to optimise the consumption */
|
|
3667
|
-
recommendedSpeed?: Maybe<Scalars["Float"]>;
|
|
3668
3677
|
/** State of charge, in kWh, of a route path segment */
|
|
3669
3678
|
stateOfCharge?: Maybe<Scalars["Float"]>;
|
|
3670
3679
|
};
|
|
3671
3680
|
|
|
3672
3681
|
/** The season of the route */
|
|
3673
3682
|
export enum RouteSeason {
|
|
3674
|
-
/** We fetch the current weather conditions */
|
|
3675
|
-
CURRENT = "current",
|
|
3676
3683
|
/** We suppose it is summer and we have the best weather conditions */
|
|
3677
3684
|
SUMMER = "summer",
|
|
3678
3685
|
/** We suppose it is winter and we have the worst weather conditions */
|
|
3679
|
-
WINTER = "winter"
|
|
3686
|
+
WINTER = "winter",
|
|
3687
|
+
/** We fetch the current weather conditions */
|
|
3688
|
+
CURRENT = "current"
|
|
3680
3689
|
}
|
|
3681
3690
|
|
|
3682
3691
|
export type RouteStationsAlong = {
|
|
3683
|
-
/** Distance in meters between station and route path */
|
|
3684
|
-
distance?: Maybe<Scalars["Int"]>;
|
|
3685
3692
|
/** The ID of station */
|
|
3686
3693
|
id?: Maybe<Scalars["String"]>;
|
|
3687
3694
|
/** Geojson location of a station */
|
|
3688
3695
|
location?: Maybe<Point>;
|
|
3689
|
-
/** The station uses a preferred operator */
|
|
3690
|
-
preferredOperator?: Maybe<Scalars["Boolean"]>;
|
|
3691
3696
|
/** Speed of a station. A station along a route can be either fast or turbo */
|
|
3692
3697
|
speed?: Maybe<StationSpeedType>;
|
|
3693
3698
|
/** Status of a station */
|
|
3694
3699
|
status?: Maybe<ChargerStatus>;
|
|
3700
|
+
/** The station uses a preferred operator */
|
|
3701
|
+
preferredOperator?: Maybe<Scalars["Boolean"]>;
|
|
3702
|
+
/** Distance in meters between station and route path */
|
|
3703
|
+
distance?: Maybe<Scalars["Int"]>;
|
|
3695
3704
|
};
|
|
3696
3705
|
|
|
3697
3706
|
/** The status of a route. The status can be pending, processing, done, not_found or error */
|
|
3698
3707
|
export enum RouteStatus {
|
|
3699
|
-
/** We finished computing the route, with a result. Final status */
|
|
3700
|
-
DONE = "done",
|
|
3701
|
-
/** An error occurred while computing the route. Final status */
|
|
3702
|
-
ERROR = "error",
|
|
3703
|
-
/** We finished the computing the route, without any result. Final status */
|
|
3704
|
-
NOT_FOUND = "not_found",
|
|
3705
3708
|
/** Route is queued and pending processing. Temporary status */
|
|
3706
3709
|
PENDING = "pending",
|
|
3707
3710
|
/** We are computing the route for your request. Temporary status */
|
|
3708
|
-
PROCESSING = "processing"
|
|
3711
|
+
PROCESSING = "processing",
|
|
3712
|
+
/** We finished computing the route, with a result. Final status */
|
|
3713
|
+
DONE = "done",
|
|
3714
|
+
/** We finished the computing the route, without any result. Final status */
|
|
3715
|
+
NOT_FOUND = "not_found",
|
|
3716
|
+
/** An error occurred while computing the route. Final status */
|
|
3717
|
+
ERROR = "error"
|
|
3709
3718
|
}
|
|
3710
3719
|
|
|
3711
3720
|
export type RouteStep = {
|
|
3712
|
-
/** Total enery used in a step in kWh */
|
|
3713
|
-
consumption?: Maybe<Scalars["Float"]>;
|
|
3714
|
-
/** Distance from the start to the end of a step, in meters */
|
|
3715
|
-
distance?: Maybe<Scalars["Int"]>;
|
|
3716
|
-
/** Total drive time from the start to the end of a step, in seconds */
|
|
3717
|
-
duration?: Maybe<Scalars["Int"]>;
|
|
3718
3721
|
/** ID of a step */
|
|
3719
3722
|
id?: Maybe<Scalars["ID"]>;
|
|
3720
|
-
/** Polyline containing encoded coordinates */
|
|
3721
|
-
polyline?: Maybe<Scalars["String"]>;
|
|
3722
3723
|
/** Type of a step */
|
|
3723
3724
|
type?: Maybe<StepType>;
|
|
3725
|
+
/** Polyline containing encoded coordinates */
|
|
3726
|
+
polyline?: Maybe<Scalars["String"]>;
|
|
3727
|
+
/** Distance from the start to the end of a step, in meters */
|
|
3728
|
+
distance?: Maybe<Scalars["Int"]>;
|
|
3729
|
+
/** Total drive time from the start to the end of a step, in seconds */
|
|
3730
|
+
duration?: Maybe<Scalars["Int"]>;
|
|
3731
|
+
/** Total enery used in a step in kWh */
|
|
3732
|
+
consumption?: Maybe<Scalars["Float"]>;
|
|
3724
3733
|
};
|
|
3725
3734
|
|
|
3726
3735
|
export type RouteSteppolylineArgs = {
|
|
@@ -3729,78 +3738,98 @@ export type RouteSteppolylineArgs = {
|
|
|
3729
3738
|
|
|
3730
3739
|
/** Tags of a route */
|
|
3731
3740
|
export enum RouteTagType {
|
|
3732
|
-
CROSSBORDER = "crossborder",
|
|
3733
|
-
FERRY = "ferry",
|
|
3734
|
-
HIGHWAY = "highway",
|
|
3735
3741
|
ROAD = "road",
|
|
3742
|
+
HIGHWAY = "highway",
|
|
3736
3743
|
TOLL = "toll",
|
|
3737
|
-
|
|
3744
|
+
FERRY = "ferry",
|
|
3745
|
+
WALKING = "walking",
|
|
3746
|
+
CROSSBORDER = "crossborder"
|
|
3738
3747
|
}
|
|
3739
3748
|
|
|
3740
3749
|
/** Standards(plug type) stats model */
|
|
3741
3750
|
export type StandardStats = {
|
|
3742
|
-
/** The total number of stations with the specified plug */
|
|
3743
|
-
total?: Maybe<Scalars["Int"]>;
|
|
3744
3751
|
/** The plug type */
|
|
3745
3752
|
type?: Maybe<ConnectorType>;
|
|
3753
|
+
/** The total number of stations with the specified plug */
|
|
3754
|
+
total?: Maybe<Scalars["Int"]>;
|
|
3746
3755
|
};
|
|
3747
3756
|
|
|
3748
3757
|
/** Station data which extends OCPI Location */
|
|
3749
3758
|
export type Station = {
|
|
3759
|
+
/** Review of a station */
|
|
3760
|
+
review?: Maybe<ReviewStats>;
|
|
3761
|
+
/** Unique ID of a station */
|
|
3762
|
+
id: Scalars["ID"];
|
|
3763
|
+
/** ISO-3166 alpha-2 country code of a station */
|
|
3764
|
+
country_code?: Maybe<Scalars["String"]>;
|
|
3765
|
+
/** CPO ID of a CPO that 'owns' this station (following the ISO-15118 standard) */
|
|
3766
|
+
party_id?: Maybe<Scalars["String"]>;
|
|
3767
|
+
/**
|
|
3768
|
+
* Defines if a location may be published on a website or app etc.
|
|
3769
|
+
* When this is set to false, only tokens identified in the field: publish_allowed_to are allowed to show this location.
|
|
3770
|
+
* When the same location has EVSEs that may be published and may not be published, two 'locations' should be created
|
|
3771
|
+
*/
|
|
3772
|
+
publish?: Maybe<Scalars["Boolean"]>;
|
|
3773
|
+
/** Name of a charging station */
|
|
3774
|
+
name?: Maybe<Scalars["String"]>;
|
|
3750
3775
|
/** Street/block name and house number if available */
|
|
3751
3776
|
address?: Maybe<Scalars["String"]>;
|
|
3752
|
-
/** Amenities located at this location */
|
|
3753
|
-
amenities?: Maybe<Scalars["JSON"]>;
|
|
3754
|
-
/** Groups of EVSEs by power and type */
|
|
3755
|
-
chargers?: Maybe<Array<Maybe<Charger>>>;
|
|
3756
|
-
/** Indicates if the EVSEs are still charging outside the opening hours. E.g. when a parking garage closes its barriers overnight, is it allowed to charge till the next morning? Default: true */
|
|
3757
|
-
charging_when_closed?: Maybe<Scalars["Boolean"]>;
|
|
3758
3777
|
/** City or town */
|
|
3759
3778
|
city?: Maybe<Scalars["String"]>;
|
|
3760
|
-
/**
|
|
3761
|
-
|
|
3779
|
+
/** Postal code of a location, may only be omitted when a location has no postal code: in some countries charging locations at highways don’t have postal codes. */
|
|
3780
|
+
postal_code?: Maybe<Scalars["String"]>;
|
|
3781
|
+
/** State or province of a location, only to be used when relevant */
|
|
3782
|
+
state?: Maybe<Scalars["String"]>;
|
|
3762
3783
|
/** ISO 3166-1 alpha-3 code for the country of this station */
|
|
3763
3784
|
country?: Maybe<Scalars["String"]>;
|
|
3764
|
-
/**
|
|
3765
|
-
|
|
3766
|
-
/**
|
|
3767
|
-
|
|
3768
|
-
/**
|
|
3769
|
-
|
|
3770
|
-
/** Elevation (altitude) level */
|
|
3771
|
-
elevation?: Maybe<Scalars["Int"]>;
|
|
3772
|
-
/** Details of the energy supplied at a location */
|
|
3773
|
-
energy_mix?: Maybe<OCPIEnergyMix>;
|
|
3785
|
+
/** Coordinates of a location */
|
|
3786
|
+
coordinates?: Maybe<OCPIGeoLocation>;
|
|
3787
|
+
/** Geographical location of related points relevant to a user */
|
|
3788
|
+
related_locations?: Maybe<Array<Maybe<OCPIAdditionalGeoLocation>>>;
|
|
3789
|
+
/** Type of parking at a charge point location */
|
|
3790
|
+
parking_type?: Maybe<OCPIParkingType>;
|
|
3774
3791
|
/** EVSEs that belong to a station */
|
|
3775
3792
|
evses?: Maybe<Array<Maybe<EVSE>>>;
|
|
3776
|
-
/**
|
|
3777
|
-
|
|
3793
|
+
/** Human-readable directions on how to reach a station */
|
|
3794
|
+
directions?: Maybe<Array<Maybe<OCPIDisplayText>>>;
|
|
3795
|
+
/** Information about an operator */
|
|
3796
|
+
operator?: Maybe<Operator>;
|
|
3797
|
+
/** Information about a suboperator if applicable */
|
|
3798
|
+
suboperator?: Maybe<Operator>;
|
|
3799
|
+
/** Information about an owner if available */
|
|
3800
|
+
owner?: Maybe<Operator>;
|
|
3778
3801
|
/** Facilities a charging station belongs to */
|
|
3779
3802
|
facilities?: Maybe<Array<Maybe<OCPIFacility>>>;
|
|
3780
|
-
/**
|
|
3781
|
-
|
|
3803
|
+
/** Value from the IANA time zone database representing the time zone of a location. Examples: "Europe/Oslo", "Europe/Zurich". (http://www.iana.org/time-zones) */
|
|
3804
|
+
time_zone?: Maybe<Scalars["String"]>;
|
|
3805
|
+
/** Times when an EVSEs at a location can be accessed for charging */
|
|
3806
|
+
opening_times?: Maybe<OCPIHours>;
|
|
3807
|
+
/** Indicates if the EVSEs are still charging outside the opening hours. E.g. when a parking garage closes its barriers overnight, is it allowed to charge till the next morning? Default: true */
|
|
3808
|
+
charging_when_closed?: Maybe<Scalars["Boolean"]>;
|
|
3782
3809
|
/** Links to images related to a location such as photos or logos */
|
|
3783
3810
|
images?: Maybe<Array<Maybe<OCPIImage>>>;
|
|
3811
|
+
/** Details of the energy supplied at a location */
|
|
3812
|
+
energy_mix?: Maybe<OCPIEnergyMix>;
|
|
3784
3813
|
/** Timestamp when a location, or one of its EVSEs or Connectors were last updated (or created) */
|
|
3785
3814
|
last_updated?: Maybe<Scalars["DateTime"]>;
|
|
3815
|
+
/** ID provided by a station data source */
|
|
3816
|
+
external_id?: Maybe<Scalars["String"]>;
|
|
3786
3817
|
/** GeoJSON location of a charging station */
|
|
3787
3818
|
location?: Maybe<Point>;
|
|
3788
|
-
/**
|
|
3789
|
-
|
|
3790
|
-
/**
|
|
3791
|
-
|
|
3792
|
-
/**
|
|
3793
|
-
|
|
3794
|
-
/** Information about an owner if available */
|
|
3795
|
-
owner?: Maybe<Operator>;
|
|
3796
|
-
/** Type of parking at a charge point location */
|
|
3797
|
-
parking_type?: Maybe<OCPIParkingType>;
|
|
3798
|
-
/** CPO ID of a CPO that 'owns' this station (following the ISO-15118 standard) */
|
|
3799
|
-
party_id?: Maybe<Scalars["String"]>;
|
|
3819
|
+
/** Elevation (altitude) level */
|
|
3820
|
+
elevation?: Maybe<Scalars["Int"]>;
|
|
3821
|
+
/** Groups of EVSEs by power and type */
|
|
3822
|
+
chargers?: Maybe<Array<Maybe<Charger>>>;
|
|
3823
|
+
/** Amenities located at this location */
|
|
3824
|
+
amenities?: Maybe<Scalars["JSON"]>;
|
|
3800
3825
|
/** Enriched information about the physical address of a station */
|
|
3801
3826
|
physical_address?: Maybe<Address>;
|
|
3802
|
-
/**
|
|
3803
|
-
|
|
3827
|
+
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
3828
|
+
properties?: Maybe<Scalars["JSON"]>;
|
|
3829
|
+
/** A flag that indicates if a station has real-time information about the availability of its connectors */
|
|
3830
|
+
realtime?: Maybe<Scalars["Boolean"]>;
|
|
3831
|
+
/** A flag that indicates if a station is on private property */
|
|
3832
|
+
private?: Maybe<Scalars["Boolean"]>;
|
|
3804
3833
|
/** Connectors grouped by power */
|
|
3805
3834
|
power?: Maybe<Scalars["JSON"]>;
|
|
3806
3835
|
/**
|
|
@@ -3813,172 +3842,173 @@ export type Station = {
|
|
|
3813
3842
|
* @deprecated In favor of custom_properties.predicted_occupancy
|
|
3814
3843
|
*/
|
|
3815
3844
|
predicted_occupancy?: Maybe<Array<Maybe<StationPredictedOccupancy>>>;
|
|
3816
|
-
/** A flag that indicates if a station is on private property */
|
|
3817
|
-
private?: Maybe<Scalars["Boolean"]>;
|
|
3818
|
-
/** Optional object where you can store custom data you need in your application. This extends the current functionalities we offer */
|
|
3819
|
-
properties?: Maybe<Scalars["JSON"]>;
|
|
3820
|
-
/**
|
|
3821
|
-
* Defines if a location may be published on a website or app etc.
|
|
3822
|
-
* When this is set to false, only tokens identified in the field: publish_allowed_to are allowed to show this location.
|
|
3823
|
-
* When the same location has EVSEs that may be published and may not be published, two 'locations' should be created
|
|
3824
|
-
*/
|
|
3825
|
-
publish?: Maybe<Scalars["Boolean"]>;
|
|
3826
|
-
/** A flag that indicates if a station has real-time information about the availability of its connectors */
|
|
3827
|
-
realtime?: Maybe<Scalars["Boolean"]>;
|
|
3828
|
-
/** Geographical location of related points relevant to a user */
|
|
3829
|
-
related_locations?: Maybe<Array<Maybe<OCPIAdditionalGeoLocation>>>;
|
|
3830
|
-
/** Review of a station */
|
|
3831
|
-
review?: Maybe<ReviewStats>;
|
|
3832
3845
|
/** Charging speed for a station */
|
|
3833
3846
|
speed?: Maybe<StationSpeedType>;
|
|
3834
|
-
/** State or province of a location, only to be used when relevant */
|
|
3835
|
-
state?: Maybe<Scalars["String"]>;
|
|
3836
3847
|
/** Global status for a station */
|
|
3837
3848
|
status?: Maybe<ChargerStatus>;
|
|
3838
|
-
/**
|
|
3839
|
-
|
|
3840
|
-
/** Value from the IANA time zone database representing the time zone of a location. Examples: "Europe/Oslo", "Europe/Zurich". (http://www.iana.org/time-zones) */
|
|
3841
|
-
time_zone?: Maybe<Scalars["String"]>;
|
|
3849
|
+
/** Custom properties of a station. These are vendor specific and will return null values on the fields that are not supported by your station database */
|
|
3850
|
+
custom_properties?: Maybe<StationCustomProperties>;
|
|
3842
3851
|
};
|
|
3843
3852
|
|
|
3844
3853
|
/** Filter which can be applied to retrieve the station around list action */
|
|
3845
3854
|
export type StationAroundFilter = {
|
|
3846
|
-
/** Amenities available near a station */
|
|
3847
|
-
amenities?: Maybe<Array<Maybe<Amenities>>>;
|
|
3848
|
-
/** Flag that allows you to return only available stations */
|
|
3849
|
-
available_only?: Maybe<Scalars["Boolean"]>;
|
|
3850
|
-
/** Station socket or plug standards */
|
|
3851
|
-
connectors?: Maybe<Array<Maybe<ConnectorType>>>;
|
|
3852
|
-
/** Distance, in meters, to search around */
|
|
3853
|
-
distance?: Maybe<Scalars["Int"]>;
|
|
3854
3855
|
/** The GeoJSON Point of the center of the around me circle */
|
|
3855
3856
|
location?: Maybe<PointInput>;
|
|
3856
|
-
/**
|
|
3857
|
-
|
|
3857
|
+
/** Distance, in meters, to search around */
|
|
3858
|
+
distance?: Maybe<Scalars["Int"]>;
|
|
3858
3859
|
/** Powers in kWh */
|
|
3859
3860
|
powers?: Maybe<Array<Maybe<Scalars["Float"]>>>;
|
|
3861
|
+
/** Amenities available near a station */
|
|
3862
|
+
amenities?: Maybe<Array<Maybe<Amenities>>>;
|
|
3863
|
+
/** Station speed */
|
|
3864
|
+
power_groups?: Maybe<Array<Maybe<StationSpeedType>>>;
|
|
3865
|
+
/** Station socket or plug standards */
|
|
3866
|
+
connectors?: Maybe<Array<Maybe<ConnectorType>>>;
|
|
3867
|
+
/** Flag that allows you to return only available stations */
|
|
3868
|
+
available_only?: Maybe<Scalars["Boolean"]>;
|
|
3860
3869
|
/** Flag indicating if only stations that are owned by an operator from a clients ranking list are returned */
|
|
3861
3870
|
preferred_operator?: Maybe<Scalars["Boolean"]>;
|
|
3862
3871
|
};
|
|
3863
3872
|
|
|
3864
3873
|
/** Deprecated: Replaced by filter & search params */
|
|
3865
3874
|
export type StationAroundQuery = {
|
|
3866
|
-
/** Amenities available near a station. Values: restaurant, bathroom, supermarket, playground, coffee, shopping, museum, hotel, park */
|
|
3867
|
-
amenities?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
3868
|
-
/** Distance, in meters, to search around */
|
|
3869
|
-
distance?: Maybe<Scalars["Int"]>;
|
|
3870
3875
|
/** The GeoJSON Point of the center of the around me circle */
|
|
3871
3876
|
location?: Maybe<PointInput>;
|
|
3877
|
+
/** Distance, in meters, to search around */
|
|
3878
|
+
distance?: Maybe<Scalars["Int"]>;
|
|
3872
3879
|
/** Power in kWh */
|
|
3873
3880
|
power?: Maybe<Array<Maybe<Scalars["Float"]>>>;
|
|
3881
|
+
/** Amenities available near a station. Values: restaurant, bathroom, supermarket, playground, coffee, shopping, museum, hotel, park */
|
|
3882
|
+
amenities?: Maybe<Array<Maybe<Scalars["String"]>>>;
|
|
3874
3883
|
};
|
|
3875
3884
|
|
|
3876
3885
|
export type StationCustomProperties = {
|
|
3877
|
-
/** Type of access to the charging station */
|
|
3878
|
-
access_type?: Maybe<AccessType>;
|
|
3879
|
-
/** List of available ad hoc payment methods */
|
|
3880
|
-
adhoc_authorisation_method?: Maybe<Array<Maybe<AdhocAuthorisationMethod>>>;
|
|
3881
|
-
/** Charging behavior of a station */
|
|
3882
|
-
charging_behaviour?: Maybe<ChargingBehaviour>;
|
|
3883
|
-
/** Predicted station occupancy */
|
|
3884
|
-
predicted_occupancy?: Maybe<Array<Maybe<StationPredictedOccupancy>>>;
|
|
3885
|
-
/** Shows how reliable a charging station is (1 to 5; 1 = unreliable, 5 = reliable), taking into account the charging behaviour history and error values */
|
|
3886
|
-
reliability_score?: Maybe<Scalars["Int"]>;
|
|
3887
3886
|
/** List of eMSP cards accepted at a charging station */
|
|
3888
3887
|
roaming?: Maybe<Array<Maybe<StationRoaming>>>;
|
|
3889
3888
|
/** Phone number for assistance at a charging station */
|
|
3890
3889
|
support_phone_number?: Maybe<Scalars["String"]>;
|
|
3890
|
+
/** Charging behavior of a station */
|
|
3891
|
+
charging_behaviour?: Maybe<ChargingBehaviour>;
|
|
3892
|
+
/** Shows how reliable a charging station is (1 to 5; 1 = unreliable, 5 = reliable), taking into account the charging behaviour history and error values */
|
|
3893
|
+
reliability_score?: Maybe<Scalars["Int"]>;
|
|
3894
|
+
/** List of available ad hoc payment methods */
|
|
3895
|
+
adhoc_authorisation_method?: Maybe<Array<Maybe<AdhocAuthorisationMethod>>>;
|
|
3896
|
+
/** Predicted station occupancy */
|
|
3897
|
+
predicted_occupancy?: Maybe<Array<Maybe<StationPredictedOccupancy>>>;
|
|
3898
|
+
/** Type of access to the charging station */
|
|
3899
|
+
access_type?: Maybe<AccessType>;
|
|
3891
3900
|
};
|
|
3892
3901
|
|
|
3893
3902
|
/** Filter which can be applied to retrieve the station list action */
|
|
3894
3903
|
export type StationListFilter = {
|
|
3904
|
+
/** Powers in kWh */
|
|
3905
|
+
powers?: Maybe<Array<Maybe<Scalars["Float"]>>>;
|
|
3895
3906
|
/** Amenities available near a station */
|
|
3896
3907
|
amenities?: Maybe<Array<Maybe<Amenities>>>;
|
|
3897
|
-
/** Flag that allows you to return only available stations */
|
|
3898
|
-
available_only?: Maybe<Scalars["Boolean"]>;
|
|
3899
|
-
/** Station socket or plug standards */
|
|
3900
|
-
connectors?: Maybe<Array<Maybe<ConnectorType>>>;
|
|
3901
3908
|
/** Station speed */
|
|
3902
3909
|
power_groups?: Maybe<Array<Maybe<StationSpeedType>>>;
|
|
3903
|
-
/**
|
|
3904
|
-
|
|
3910
|
+
/** Station socket or plug standards */
|
|
3911
|
+
connectors?: Maybe<Array<Maybe<ConnectorType>>>;
|
|
3912
|
+
/** Flag that allows you to return only available stations */
|
|
3913
|
+
available_only?: Maybe<Scalars["Boolean"]>;
|
|
3905
3914
|
/** Flag indicating if only stations that are owned by an operator from a clients ranking list are returned */
|
|
3906
3915
|
preferred_operator?: Maybe<Scalars["Boolean"]>;
|
|
3907
3916
|
};
|
|
3908
3917
|
|
|
3909
3918
|
/** Deprecated: Replaced by filter & search params */
|
|
3910
3919
|
export type StationListQuery = {
|
|
3911
|
-
/** External ID of the station provided by the station data source */
|
|
3912
|
-
external_id?: Maybe<Scalars["String"]>;
|
|
3913
3920
|
/** ID of the station */
|
|
3914
3921
|
id?: Maybe<Scalars["ID"]>;
|
|
3922
|
+
/** External ID of the station provided by the station data source */
|
|
3923
|
+
external_id?: Maybe<Scalars["String"]>;
|
|
3915
3924
|
/** Exact name */
|
|
3916
3925
|
name?: Maybe<Scalars["String"]>;
|
|
3917
3926
|
};
|
|
3918
3927
|
|
|
3919
3928
|
/** Station availability for each weekday and hour */
|
|
3920
3929
|
export type StationPredictedAvailability = {
|
|
3921
|
-
/** The prediction for each hour 0-23 from 1 to 5 (1 - very busy ... 5 very quiet (free)) */
|
|
3922
|
-
prediction?: Maybe<Array<Maybe<Scalars["Int"]>>>;
|
|
3923
3930
|
/** Number of weekday from 1 (monday) to 7 (sunday) */
|
|
3924
3931
|
weekday?: Maybe<Scalars["Int"]>;
|
|
3932
|
+
/** The prediction for each hour 0-23 from 1 to 5 (1 - very busy ... 5 very quiet (free)) */
|
|
3933
|
+
prediction?: Maybe<Array<Maybe<Scalars["Int"]>>>;
|
|
3925
3934
|
};
|
|
3926
3935
|
|
|
3927
3936
|
/** Station occupancy for each weekday and hour */
|
|
3928
3937
|
export type StationPredictedOccupancy = {
|
|
3938
|
+
/** Number of weekday from 1 (monday) to 7 (sunday) */
|
|
3939
|
+
weekday?: Maybe<Scalars["Int"]>;
|
|
3929
3940
|
/** Occupancy on a scale from 1 to 10, where 1 means free for charging and 10 means fully occupied */
|
|
3930
3941
|
occupancy?: Maybe<Scalars["Int"]>;
|
|
3931
3942
|
/** Start of the period of the occupancy prediction (string of 'hh-mmZ' format) */
|
|
3932
3943
|
period_begin?: Maybe<Scalars["String"]>;
|
|
3933
3944
|
/** End of the period of the occupancy prediction (string of 'hh-mmZ' format) */
|
|
3934
3945
|
period_end?: Maybe<Scalars["String"]>;
|
|
3935
|
-
/** Number of weekday from 1 (monday) to 7 (sunday) */
|
|
3936
|
-
weekday?: Maybe<Scalars["Int"]>;
|
|
3937
3946
|
};
|
|
3938
3947
|
|
|
3939
3948
|
export type StationRoaming = {
|
|
3940
|
-
/** Link to native Android app for card accepted at a charging station */
|
|
3941
|
-
android_app_link?: Maybe<Scalars["String"]>;
|
|
3942
|
-
/** Name of the card accepted at a charging station */
|
|
3943
|
-
card?: Maybe<Scalars["String"]>;
|
|
3944
3949
|
/** Name of the EMSP provider */
|
|
3945
3950
|
emsp?: Maybe<Scalars["String"]>;
|
|
3951
|
+
/** Name of the card accepted at a charging station */
|
|
3952
|
+
card?: Maybe<Scalars["String"]>;
|
|
3953
|
+
/** Link to native Android app for card accepted at a charging station */
|
|
3954
|
+
android_app_link?: Maybe<Scalars["String"]>;
|
|
3946
3955
|
/** Link to native iOS app for card accepted at a charging station */
|
|
3947
3956
|
ios_app_link?: Maybe<Scalars["String"]>;
|
|
3948
3957
|
};
|
|
3949
3958
|
|
|
3950
3959
|
/** The station speed type */
|
|
3951
3960
|
export enum StationSpeedType {
|
|
3952
|
-
/** Fast charging stations (above 43 kWh and below 150 kWh) */
|
|
3953
|
-
FAST = "fast",
|
|
3954
3961
|
/** Slow charging (below 43 kWh) */
|
|
3955
3962
|
SLOW = "slow",
|
|
3963
|
+
/** Fast charging stations (above 43 kWh and below 150 kWh) */
|
|
3964
|
+
FAST = "fast",
|
|
3956
3965
|
/** Ultra fast charging stations (above 150 kWh) */
|
|
3957
3966
|
TURBO = "turbo"
|
|
3958
3967
|
}
|
|
3959
3968
|
|
|
3960
3969
|
/** The station stats model */
|
|
3961
3970
|
export type StationStats = {
|
|
3962
|
-
/** Stations count grouped by amenities */
|
|
3963
|
-
amenities?: Maybe<Array<Maybe<AmenityStats>>>;
|
|
3964
|
-
/** Stations count grouped by power */
|
|
3965
|
-
power?: Maybe<Array<Maybe<PowerStats>>>;
|
|
3966
3971
|
/** Stations count grouped by standards */
|
|
3967
3972
|
standards?: Maybe<Array<Maybe<StandardStats>>>;
|
|
3973
|
+
/** Stations count grouped by power */
|
|
3974
|
+
power?: Maybe<Array<Maybe<PowerStats>>>;
|
|
3975
|
+
/** Stations count grouped by amenities */
|
|
3976
|
+
amenities?: Maybe<Array<Maybe<AmenityStats>>>;
|
|
3968
3977
|
};
|
|
3969
3978
|
|
|
3970
3979
|
/** Types of a route step */
|
|
3971
3980
|
export enum StepType {
|
|
3972
|
-
/** This step is a crossborder */
|
|
3973
|
-
CROSSBORDER = "crossborder",
|
|
3974
|
-
/** This step is a ferry */
|
|
3975
|
-
FERRY = "ferry",
|
|
3976
|
-
/** This step is a highway */
|
|
3977
|
-
HIGHWAY = "highway",
|
|
3978
3981
|
/** This step is a road */
|
|
3979
3982
|
ROAD = "road",
|
|
3983
|
+
/** This step is a highway */
|
|
3984
|
+
HIGHWAY = "highway",
|
|
3980
3985
|
/** This step is a toll road */
|
|
3981
3986
|
TOLL = "toll",
|
|
3987
|
+
/** This step is a ferry */
|
|
3988
|
+
FERRY = "ferry",
|
|
3982
3989
|
/** This step is reachable by walking */
|
|
3983
|
-
WALKING = "walking"
|
|
3990
|
+
WALKING = "walking",
|
|
3991
|
+
/** This step is a crossborder */
|
|
3992
|
+
CROSSBORDER = "crossborder"
|
|
3984
3993
|
}
|
|
3994
|
+
|
|
3995
|
+
export type Subscription = {
|
|
3996
|
+
/** [BETA] Subscribe to an isoline label in order to receive updates */
|
|
3997
|
+
isoline?: Maybe<Isoline>;
|
|
3998
|
+
/** [BETA] Subscribe to navigation session system event updates. We strongly recommend using this at all times to not miss any updates */
|
|
3999
|
+
navigationUpdatedById?: Maybe<Navigation>;
|
|
4000
|
+
/** Subscription for a specific route was updated in the system event */
|
|
4001
|
+
routeUpdatedById?: Maybe<Route>;
|
|
4002
|
+
};
|
|
4003
|
+
|
|
4004
|
+
export type SubscriptionisolineArgs = {
|
|
4005
|
+
id: Scalars["ID"];
|
|
4006
|
+
};
|
|
4007
|
+
|
|
4008
|
+
export type SubscriptionnavigationUpdatedByIdArgs = {
|
|
4009
|
+
id: Scalars["ID"];
|
|
4010
|
+
};
|
|
4011
|
+
|
|
4012
|
+
export type SubscriptionrouteUpdatedByIdArgs = {
|
|
4013
|
+
id: Scalars["ID"];
|
|
4014
|
+
};
|