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