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