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