v230

   1from typing import Any, List, Optional, TypeVar, Callable, Type, cast
   2from enum import Enum
   3
   4
   5T = TypeVar("T")
   6EnumT = TypeVar("EnumT", bound=Enum)
   7
   8
   9def from_float(x: Any) -> float:
  10    assert isinstance(x, (float, int)) and not isinstance(x, bool)
  11    return float(x)
  12
  13
  14def from_int(x: Any) -> int:
  15    assert isinstance(x, int) and not isinstance(x, bool)
  16    return x
  17
  18
  19def to_float(x: Any) -> float:
  20    assert isinstance(x, (int, float))
  21    return x
  22
  23
  24def from_none(x: Any) -> Any:
  25    assert x is None
  26    return x
  27
  28
  29def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
  30    assert isinstance(x, list)
  31    return [f(y) for y in x]
  32
  33
  34def from_union(fs, x):
  35    for f in fs:
  36        try:
  37            return f(x)
  38        except:
  39            pass
  40    assert False
  41
  42
  43def from_str(x: Any) -> str:
  44    assert isinstance(x, str)
  45    return x
  46
  47
  48def to_class(c: Type[T], x: Any) -> dict:
  49    assert isinstance(x, c)
  50    return cast(Any, x).to_dict()
  51
  52
  53def to_enum(c: Type[EnumT], x: Any) -> EnumT:
  54    assert isinstance(x, c)
  55    return x.value
  56
  57
  58def from_bool(x: Any) -> bool:
  59    assert isinstance(x, bool)
  60    return x
  61
  62
  63class ChargingProfilePeriod:
  64    limit: float
  65    start_period: int
  66
  67    def __init__(self, limit: float, start_period: int) -> None:
  68        self.limit = limit
  69        self.start_period = start_period
  70
  71    @staticmethod
  72    def from_dict(obj: Any) -> 'ChargingProfilePeriod':
  73        assert isinstance(obj, dict)
  74        limit = from_float(obj.get("limit"))
  75        start_period = from_int(obj.get("start_period"))
  76        return ChargingProfilePeriod(limit, start_period)
  77
  78    def to_dict(self) -> dict:
  79        result: dict = {}
  80        result["limit"] = to_float(self.limit)
  81        result["start_period"] = from_int(self.start_period)
  82        return result
  83
  84
  85class ChargingRateUnit(Enum):
  86    A = "A"
  87    W = "W"
  88
  89
  90class ChargingProfile:
  91    charging_profile_period: Optional[List[ChargingProfilePeriod]]
  92    charging_rate_unit: ChargingRateUnit
  93    duration: Optional[int]
  94    min_charging_rate: Optional[float]
  95    start_date_time: Optional[str]
  96
  97    def __init__(self, charging_profile_period: Optional[List[ChargingProfilePeriod]], charging_rate_unit: ChargingRateUnit, duration: Optional[int], min_charging_rate: Optional[float], start_date_time: Optional[str]) -> None:
  98        self.charging_profile_period = charging_profile_period
  99        self.charging_rate_unit = charging_rate_unit
 100        self.duration = duration
 101        self.min_charging_rate = min_charging_rate
 102        self.start_date_time = start_date_time
 103
 104    @staticmethod
 105    def from_dict(obj: Any) -> 'ChargingProfile':
 106        assert isinstance(obj, dict)
 107        charging_profile_period = from_union([from_none, lambda x: from_list(ChargingProfilePeriod.from_dict, x)], obj.get("charging_profile_period"))
 108        charging_rate_unit = ChargingRateUnit(obj.get("charging_rate_unit"))
 109        duration = from_union([from_none, from_int], obj.get("duration"))
 110        min_charging_rate = from_union([from_none, from_float], obj.get("min_charging_rate"))
 111        start_date_time = from_union([from_none, from_str], obj.get("start_date_time"))
 112        return ChargingProfile(charging_profile_period, charging_rate_unit, duration, min_charging_rate, start_date_time)
 113
 114    def to_dict(self) -> dict:
 115        result: dict = {}
 116        if self.charging_profile_period is not None:
 117            result["charging_profile_period"] = from_union([from_none, lambda x: from_list(lambda x: to_class(ChargingProfilePeriod, x), x)], self.charging_profile_period)
 118        result["charging_rate_unit"] = to_enum(ChargingRateUnit, self.charging_rate_unit)
 119        if self.duration is not None:
 120            result["duration"] = from_union([from_none, from_int], self.duration)
 121        if self.min_charging_rate is not None:
 122            result["min_charging_rate"] = from_union([from_none, to_float], self.min_charging_rate)
 123        if self.start_date_time is not None:
 124            result["start_date_time"] = from_union([from_none, from_str], self.start_date_time)
 125        return result
 126
 127
 128class ActiveChargingProfile:
 129    charging_profile: ChargingProfile
 130    start_date_time: str
 131
 132    def __init__(self, charging_profile: ChargingProfile, start_date_time: str) -> None:
 133        self.charging_profile = charging_profile
 134        self.start_date_time = start_date_time
 135
 136    @staticmethod
 137    def from_dict(obj: Any) -> 'ActiveChargingProfile':
 138        assert isinstance(obj, dict)
 139        charging_profile = ChargingProfile.from_dict(obj.get("charging_profile"))
 140        start_date_time = from_str(obj.get("start_date_time"))
 141        return ActiveChargingProfile(charging_profile, start_date_time)
 142
 143    def to_dict(self) -> dict:
 144        result: dict = {}
 145        result["charging_profile"] = to_class(ChargingProfile, self.charging_profile)
 146        result["start_date_time"] = from_str(self.start_date_time)
 147        return result
 148
 149
 150class ChargingProfileResultType(Enum):
 151    ACCEPTED = "ACCEPTED"
 152    REJECTED = "REJECTED"
 153    UNKNOWN = "UNKNOWN"
 154
 155
 156class ActiveChargingProfileResult:
 157    profile: Optional[ActiveChargingProfile]
 158    result: ChargingProfileResultType
 159
 160    def __init__(self, profile: Optional[ActiveChargingProfile], result: ChargingProfileResultType) -> None:
 161        self.profile = profile
 162        self.result = result
 163
 164    @staticmethod
 165    def from_dict(obj: Any) -> 'ActiveChargingProfileResult':
 166        assert isinstance(obj, dict)
 167        profile = from_union([ActiveChargingProfile.from_dict, from_none], obj.get("profile"))
 168        result = ChargingProfileResultType(obj.get("result"))
 169        return ActiveChargingProfileResult(profile, result)
 170
 171    def to_dict(self) -> dict:
 172        result: dict = {}
 173        if self.profile is not None:
 174            result["profile"] = from_union([lambda x: to_class(ActiveChargingProfile, x), from_none], self.profile)
 175        result["result"] = to_enum(ChargingProfileResultType, self.result)
 176        return result
 177
 178
 179class AllowedType(Enum):
 180    ALLOWED = "ALLOWED"
 181    BLOCKED = "BLOCKED"
 182    EXPIRED = "EXPIRED"
 183    NOT_ALLOWED = "NOT_ALLOWED"
 184    NO_CREDIT = "NO_CREDIT"
 185
 186
 187class DisplayText:
 188    language: str
 189    text: str
 190
 191    def __init__(self, language: str, text: str) -> None:
 192        self.language = language
 193        self.text = text
 194
 195    @staticmethod
 196    def from_dict(obj: Any) -> 'DisplayText':
 197        assert isinstance(obj, dict)
 198        language = from_str(obj.get("language"))
 199        text = from_str(obj.get("text"))
 200        return DisplayText(language, text)
 201
 202    def to_dict(self) -> dict:
 203        result: dict = {}
 204        result["language"] = from_str(self.language)
 205        result["text"] = from_str(self.text)
 206        return result
 207
 208
 209class LocationReferences:
 210    evse_uids: Optional[List[str]]
 211    location_id: str
 212
 213    def __init__(self, evse_uids: Optional[List[str]], location_id: str) -> None:
 214        self.evse_uids = evse_uids
 215        self.location_id = location_id
 216
 217    @staticmethod
 218    def from_dict(obj: Any) -> 'LocationReferences':
 219        assert isinstance(obj, dict)
 220        evse_uids = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("evse_uids"))
 221        location_id = from_str(obj.get("location_id"))
 222        return LocationReferences(evse_uids, location_id)
 223
 224    def to_dict(self) -> dict:
 225        result: dict = {}
 226        if self.evse_uids is not None:
 227            result["evse_uids"] = from_union([from_none, lambda x: from_list(from_str, x)], self.evse_uids)
 228        result["location_id"] = from_str(self.location_id)
 229        return result
 230
 231
 232class ProfileType(Enum):
 233    CHEAP = "CHEAP"
 234    FAST = "FAST"
 235    GREEN = "GREEN"
 236    REGULAR = "REGULAR"
 237
 238
 239class EnergyContract:
 240    contract_id: Optional[str]
 241    supplier_name: str
 242
 243    def __init__(self, contract_id: Optional[str], supplier_name: str) -> None:
 244        self.contract_id = contract_id
 245        self.supplier_name = supplier_name
 246
 247    @staticmethod
 248    def from_dict(obj: Any) -> 'EnergyContract':
 249        assert isinstance(obj, dict)
 250        contract_id = from_union([from_none, from_str], obj.get("contract_id"))
 251        supplier_name = from_str(obj.get("supplier_name"))
 252        return EnergyContract(contract_id, supplier_name)
 253
 254    def to_dict(self) -> dict:
 255        result: dict = {}
 256        if self.contract_id is not None:
 257            result["contract_id"] = from_union([from_none, from_str], self.contract_id)
 258        result["supplier_name"] = from_str(self.supplier_name)
 259        return result
 260
 261
 262class TokenType(Enum):
 263    AD_HOC_USER = "AD_HOC_USER"
 264    APP_USER = "APP_USER"
 265    EMAID = "EMAID"
 266    OTHER = "OTHER"
 267    RFID = "RFID"
 268
 269
 270class WhitelistType(Enum):
 271    ALLOWED = "ALLOWED"
 272    ALLOWED_OFFLINE = "ALLOWED_OFFLINE"
 273    ALWAYS = "ALWAYS"
 274    NEVER = "NEVER"
 275
 276
 277class Token:
 278    contract_id: str
 279    country_code: str
 280    default_profile_type: Optional[ProfileType]
 281    energy_contract: Optional[EnergyContract]
 282    group_id: Optional[str]
 283    issuer: str
 284    language: Optional[str]
 285    last_updated: str
 286    party_id: str
 287    type: TokenType
 288    uid: str
 289    valid: bool
 290    visual_number: Optional[str]
 291    whitelist: WhitelistType
 292
 293    def __init__(self, contract_id: str, country_code: str, default_profile_type: Optional[ProfileType], energy_contract: Optional[EnergyContract], group_id: Optional[str], issuer: str, language: Optional[str], last_updated: str, party_id: str, type: TokenType, uid: str, valid: bool, visual_number: Optional[str], whitelist: WhitelistType) -> None:
 294        self.contract_id = contract_id
 295        self.country_code = country_code
 296        self.default_profile_type = default_profile_type
 297        self.energy_contract = energy_contract
 298        self.group_id = group_id
 299        self.issuer = issuer
 300        self.language = language
 301        self.last_updated = last_updated
 302        self.party_id = party_id
 303        self.type = type
 304        self.uid = uid
 305        self.valid = valid
 306        self.visual_number = visual_number
 307        self.whitelist = whitelist
 308
 309    @staticmethod
 310    def from_dict(obj: Any) -> 'Token':
 311        assert isinstance(obj, dict)
 312        contract_id = from_str(obj.get("contract_id"))
 313        country_code = from_str(obj.get("country_code"))
 314        default_profile_type = from_union([from_none, ProfileType], obj.get("default_profile_type"))
 315        energy_contract = from_union([from_none, EnergyContract.from_dict], obj.get("energy_contract"))
 316        group_id = from_union([from_none, from_str], obj.get("group_id"))
 317        issuer = from_str(obj.get("issuer"))
 318        language = from_union([from_none, from_str], obj.get("language"))
 319        last_updated = from_str(obj.get("last_updated"))
 320        party_id = from_str(obj.get("party_id"))
 321        type = TokenType(obj.get("type"))
 322        uid = from_str(obj.get("uid"))
 323        valid = from_bool(obj.get("valid"))
 324        visual_number = from_union([from_none, from_str], obj.get("visual_number"))
 325        whitelist = WhitelistType(obj.get("whitelist"))
 326        return Token(contract_id, country_code, default_profile_type, energy_contract, group_id, issuer, language, last_updated, party_id, type, uid, valid, visual_number, whitelist)
 327
 328    def to_dict(self) -> dict:
 329        result: dict = {}
 330        result["contract_id"] = from_str(self.contract_id)
 331        result["country_code"] = from_str(self.country_code)
 332        if self.default_profile_type is not None:
 333            result["default_profile_type"] = from_union([from_none, lambda x: to_enum(ProfileType, x)], self.default_profile_type)
 334        if self.energy_contract is not None:
 335            result["energy_contract"] = from_union([from_none, lambda x: to_class(EnergyContract, x)], self.energy_contract)
 336        if self.group_id is not None:
 337            result["group_id"] = from_union([from_none, from_str], self.group_id)
 338        result["issuer"] = from_str(self.issuer)
 339        if self.language is not None:
 340            result["language"] = from_union([from_none, from_str], self.language)
 341        result["last_updated"] = from_str(self.last_updated)
 342        result["party_id"] = from_str(self.party_id)
 343        result["type"] = to_enum(TokenType, self.type)
 344        result["uid"] = from_str(self.uid)
 345        result["valid"] = from_bool(self.valid)
 346        if self.visual_number is not None:
 347            result["visual_number"] = from_union([from_none, from_str], self.visual_number)
 348        result["whitelist"] = to_enum(WhitelistType, self.whitelist)
 349        return result
 350
 351
 352class AuthorizationInfo:
 353    allowed: AllowedType
 354    authorization_reference: Optional[str]
 355    info: Optional[DisplayText]
 356    location: Optional[LocationReferences]
 357    token: Token
 358
 359    def __init__(self, allowed: AllowedType, authorization_reference: Optional[str], info: Optional[DisplayText], location: Optional[LocationReferences], token: Token) -> None:
 360        self.allowed = allowed
 361        self.authorization_reference = authorization_reference
 362        self.info = info
 363        self.location = location
 364        self.token = token
 365
 366    @staticmethod
 367    def from_dict(obj: Any) -> 'AuthorizationInfo':
 368        assert isinstance(obj, dict)
 369        allowed = AllowedType(obj.get("allowed"))
 370        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
 371        info = from_union([from_none, DisplayText.from_dict], obj.get("info"))
 372        location = from_union([from_none, LocationReferences.from_dict], obj.get("location"))
 373        token = Token.from_dict(obj.get("token"))
 374        return AuthorizationInfo(allowed, authorization_reference, info, location, token)
 375
 376    def to_dict(self) -> dict:
 377        result: dict = {}
 378        result["allowed"] = to_enum(AllowedType, self.allowed)
 379        if self.authorization_reference is not None:
 380            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
 381        if self.info is not None:
 382            result["info"] = from_union([from_none, lambda x: to_class(DisplayText, x)], self.info)
 383        if self.location is not None:
 384            result["location"] = from_union([from_none, lambda x: to_class(LocationReferences, x)], self.location)
 385        result["token"] = to_class(Token, self.token)
 386        return result
 387
 388
 389class CancelReservation:
 390    reservation_id: str
 391    response_url: str
 392
 393    def __init__(self, reservation_id: str, response_url: str) -> None:
 394        self.reservation_id = reservation_id
 395        self.response_url = response_url
 396
 397    @staticmethod
 398    def from_dict(obj: Any) -> 'CancelReservation':
 399        assert isinstance(obj, dict)
 400        reservation_id = from_str(obj.get("reservation_id"))
 401        response_url = from_str(obj.get("response_url"))
 402        return CancelReservation(reservation_id, response_url)
 403
 404    def to_dict(self) -> dict:
 405        result: dict = {}
 406        result["reservation_id"] = from_str(self.reservation_id)
 407        result["response_url"] = from_str(self.response_url)
 408        return result
 409
 410
 411class AuthMethod(Enum):
 412    AUTH_REQUEST = "AUTH_REQUEST"
 413    COMMAND = "COMMAND"
 414    WHITELIST = "WHITELIST"
 415
 416
 417class ConnectorFormat(Enum):
 418    CABLE = "CABLE"
 419    SOCKET = "SOCKET"
 420
 421
 422class PowerType(Enum):
 423    AC_1__PHASE = "AC_1_PHASE"
 424    AC_2__PHASE = "AC_2_PHASE"
 425    AC_2__PHASE_SPLIT = "AC_2_PHASE_SPLIT"
 426    AC_3__PHASE = "AC_3_PHASE"
 427    DC = "DC"
 428
 429
 430class ConnectorType(Enum):
 431    CHADEMO = "CHADEMO"
 432    CHAOJI = "CHAOJI"
 433    DOMESTIC_A = "DOMESTIC_A"
 434    DOMESTIC_B = "DOMESTIC_B"
 435    DOMESTIC_C = "DOMESTIC_C"
 436    DOMESTIC_D = "DOMESTIC_D"
 437    DOMESTIC_E = "DOMESTIC_E"
 438    DOMESTIC_F = "DOMESTIC_F"
 439    DOMESTIC_G = "DOMESTIC_G"
 440    DOMESTIC_H = "DOMESTIC_H"
 441    DOMESTIC_I = "DOMESTIC_I"
 442    DOMESTIC_J = "DOMESTIC_J"
 443    DOMESTIC_K = "DOMESTIC_K"
 444    DOMESTIC_L = "DOMESTIC_L"
 445    DOMESTIC_M = "DOMESTIC_M"
 446    DOMESTIC_N = "DOMESTIC_N"
 447    DOMESTIC_O = "DOMESTIC_O"
 448    GBT_AC = "GBT_AC"
 449    GBT_DC = "GBT_DC"
 450    IEC_60309_2__SINGLE_16 = "IEC_60309_2_single_16"
 451    IEC_60309_2__THREE_16 = "IEC_60309_2_three_16"
 452    IEC_60309_2__THREE_32 = "IEC_60309_2_three_32"
 453    IEC_60309_2__THREE_64 = "IEC_60309_2_three_64"
 454    IEC_62196__T1 = "IEC_62196_T1"
 455    IEC_62196__T1_COMBO = "IEC_62196_T1_COMBO"
 456    IEC_62196__T2 = "IEC_62196_T2"
 457    IEC_62196__T2_COMBO = "IEC_62196_T2_COMBO"
 458    IEC_62196__T3_A = "IEC_62196_T3A"
 459    IEC_62196__T3_C = "IEC_62196_T3C"
 460    MCS = "MCS"
 461    NEMA_10_30 = "NEMA_10_30"
 462    NEMA_10_50 = "NEMA_10_50"
 463    NEMA_14_30 = "NEMA_14_30"
 464    NEMA_14_50 = "NEMA_14_50"
 465    NEMA_5_20 = "NEMA_5_20"
 466    NEMA_6_30 = "NEMA_6_30"
 467    NEMA_6_50 = "NEMA_6_50"
 468    PANTOGRAPH_BOTTOM_UP = "PANTOGRAPH_BOTTOM_UP"
 469    PANTOGRAPH_TOP_DOWN = "PANTOGRAPH_TOP_DOWN"
 470    SAE_J3400 = "SAE_J3400"
 471    TESLA_R = "TESLA_R"
 472    TESLA_S = "TESLA_S"
 473
 474
 475class GeoLocation:
 476    latitude: str
 477    longitude: str
 478
 479    def __init__(self, latitude: str, longitude: str) -> None:
 480        self.latitude = latitude
 481        self.longitude = longitude
 482
 483    @staticmethod
 484    def from_dict(obj: Any) -> 'GeoLocation':
 485        assert isinstance(obj, dict)
 486        latitude = from_str(obj.get("latitude"))
 487        longitude = from_str(obj.get("longitude"))
 488        return GeoLocation(latitude, longitude)
 489
 490    def to_dict(self) -> dict:
 491        result: dict = {}
 492        result["latitude"] = from_str(self.latitude)
 493        result["longitude"] = from_str(self.longitude)
 494        return result
 495
 496
 497class CdrLocation:
 498    address: str
 499    city: str
 500    connector_format: ConnectorFormat
 501    connector_id: str
 502    connector_power_type: PowerType
 503    connector_standard: ConnectorType
 504    coordinates: GeoLocation
 505    country: str
 506    evse_id: str
 507    evse_uid: str
 508    id: str
 509    name: Optional[str]
 510    postal_code: Optional[str]
 511    state: Optional[str]
 512
 513    def __init__(self, address: str, city: str, connector_format: ConnectorFormat, connector_id: str, connector_power_type: PowerType, connector_standard: ConnectorType, coordinates: GeoLocation, country: str, evse_id: str, evse_uid: str, id: str, name: Optional[str], postal_code: Optional[str], state: Optional[str]) -> None:
 514        self.address = address
 515        self.city = city
 516        self.connector_format = connector_format
 517        self.connector_id = connector_id
 518        self.connector_power_type = connector_power_type
 519        self.connector_standard = connector_standard
 520        self.coordinates = coordinates
 521        self.country = country
 522        self.evse_id = evse_id
 523        self.evse_uid = evse_uid
 524        self.id = id
 525        self.name = name
 526        self.postal_code = postal_code
 527        self.state = state
 528
 529    @staticmethod
 530    def from_dict(obj: Any) -> 'CdrLocation':
 531        assert isinstance(obj, dict)
 532        address = from_str(obj.get("address"))
 533        city = from_str(obj.get("city"))
 534        connector_format = ConnectorFormat(obj.get("connector_format"))
 535        connector_id = from_str(obj.get("connector_id"))
 536        connector_power_type = PowerType(obj.get("connector_power_type"))
 537        connector_standard = ConnectorType(obj.get("connector_standard"))
 538        coordinates = GeoLocation.from_dict(obj.get("coordinates"))
 539        country = from_str(obj.get("country"))
 540        evse_id = from_str(obj.get("evse_id"))
 541        evse_uid = from_str(obj.get("evse_uid"))
 542        id = from_str(obj.get("id"))
 543        name = from_union([from_none, from_str], obj.get("name"))
 544        postal_code = from_union([from_none, from_str], obj.get("postal_code"))
 545        state = from_union([from_none, from_str], obj.get("state"))
 546        return CdrLocation(address, city, connector_format, connector_id, connector_power_type, connector_standard, coordinates, country, evse_id, evse_uid, id, name, postal_code, state)
 547
 548    def to_dict(self) -> dict:
 549        result: dict = {}
 550        result["address"] = from_str(self.address)
 551        result["city"] = from_str(self.city)
 552        result["connector_format"] = to_enum(ConnectorFormat, self.connector_format)
 553        result["connector_id"] = from_str(self.connector_id)
 554        result["connector_power_type"] = to_enum(PowerType, self.connector_power_type)
 555        result["connector_standard"] = to_enum(ConnectorType, self.connector_standard)
 556        result["coordinates"] = to_class(GeoLocation, self.coordinates)
 557        result["country"] = from_str(self.country)
 558        result["evse_id"] = from_str(self.evse_id)
 559        result["evse_uid"] = from_str(self.evse_uid)
 560        result["id"] = from_str(self.id)
 561        if self.name is not None:
 562            result["name"] = from_union([from_none, from_str], self.name)
 563        if self.postal_code is not None:
 564            result["postal_code"] = from_union([from_none, from_str], self.postal_code)
 565        if self.state is not None:
 566            result["state"] = from_union([from_none, from_str], self.state)
 567        return result
 568
 569
 570class CdrToken:
 571    contract_id: str
 572    country_code: str
 573    party_id: str
 574    type: TokenType
 575    uid: str
 576
 577    def __init__(self, contract_id: str, country_code: str, party_id: str, type: TokenType, uid: str) -> None:
 578        self.contract_id = contract_id
 579        self.country_code = country_code
 580        self.party_id = party_id
 581        self.type = type
 582        self.uid = uid
 583
 584    @staticmethod
 585    def from_dict(obj: Any) -> 'CdrToken':
 586        assert isinstance(obj, dict)
 587        contract_id = from_str(obj.get("contract_id"))
 588        country_code = from_str(obj.get("country_code"))
 589        party_id = from_str(obj.get("party_id"))
 590        type = TokenType(obj.get("type"))
 591        uid = from_str(obj.get("uid"))
 592        return CdrToken(contract_id, country_code, party_id, type, uid)
 593
 594    def to_dict(self) -> dict:
 595        result: dict = {}
 596        result["contract_id"] = from_str(self.contract_id)
 597        result["country_code"] = from_str(self.country_code)
 598        result["party_id"] = from_str(self.party_id)
 599        result["type"] = to_enum(TokenType, self.type)
 600        result["uid"] = from_str(self.uid)
 601        return result
 602
 603
 604class CdrDimensionType(Enum):
 605    CURRENT = "CURRENT"
 606    ENERGY = "ENERGY"
 607    ENERGY_EXPORT = "ENERGY_EXPORT"
 608    ENERGY_IMPORT = "ENERGY_IMPORT"
 609    MAX_CURRENT = "MAX_CURRENT"
 610    MAX_POWER = "MAX_POWER"
 611    MIN_CURRENT = "MIN_CURRENT"
 612    MIN_POWER = "MIN_POWER"
 613    PARKING_TIME = "PARKING_TIME"
 614    POWER = "POWER"
 615    RESERVATION_TIME = "RESERVATION_TIME"
 616    STATE_OF_CHARGE = "STATE_OF_CHARGE"
 617    TIME = "TIME"
 618
 619
 620class CdrDimension:
 621    type: CdrDimensionType
 622    volume: float
 623
 624    def __init__(self, type: CdrDimensionType, volume: float) -> None:
 625        self.type = type
 626        self.volume = volume
 627
 628    @staticmethod
 629    def from_dict(obj: Any) -> 'CdrDimension':
 630        assert isinstance(obj, dict)
 631        type = CdrDimensionType(obj.get("type"))
 632        volume = from_float(obj.get("volume"))
 633        return CdrDimension(type, volume)
 634
 635    def to_dict(self) -> dict:
 636        result: dict = {}
 637        result["type"] = to_enum(CdrDimensionType, self.type)
 638        result["volume"] = to_float(self.volume)
 639        return result
 640
 641
 642class ChargingPeriod:
 643    dimensions: List[CdrDimension]
 644    start_date_time: str
 645    tariff_id: Optional[str]
 646
 647    def __init__(self, dimensions: List[CdrDimension], start_date_time: str, tariff_id: Optional[str]) -> None:
 648        self.dimensions = dimensions
 649        self.start_date_time = start_date_time
 650        self.tariff_id = tariff_id
 651
 652    @staticmethod
 653    def from_dict(obj: Any) -> 'ChargingPeriod':
 654        assert isinstance(obj, dict)
 655        dimensions = from_list(CdrDimension.from_dict, obj.get("dimensions"))
 656        start_date_time = from_str(obj.get("start_date_time"))
 657        tariff_id = from_union([from_none, from_str], obj.get("tariff_id"))
 658        return ChargingPeriod(dimensions, start_date_time, tariff_id)
 659
 660    def to_dict(self) -> dict:
 661        result: dict = {}
 662        result["dimensions"] = from_list(lambda x: to_class(CdrDimension, x), self.dimensions)
 663        result["start_date_time"] = from_str(self.start_date_time)
 664        if self.tariff_id is not None:
 665            result["tariff_id"] = from_union([from_none, from_str], self.tariff_id)
 666        return result
 667
 668
 669class SignedValue:
 670    nature: str
 671    plain_data: str
 672    signed_data: str
 673
 674    def __init__(self, nature: str, plain_data: str, signed_data: str) -> None:
 675        self.nature = nature
 676        self.plain_data = plain_data
 677        self.signed_data = signed_data
 678
 679    @staticmethod
 680    def from_dict(obj: Any) -> 'SignedValue':
 681        assert isinstance(obj, dict)
 682        nature = from_str(obj.get("nature"))
 683        plain_data = from_str(obj.get("plain_data"))
 684        signed_data = from_str(obj.get("signed_data"))
 685        return SignedValue(nature, plain_data, signed_data)
 686
 687    def to_dict(self) -> dict:
 688        result: dict = {}
 689        result["nature"] = from_str(self.nature)
 690        result["plain_data"] = from_str(self.plain_data)
 691        result["signed_data"] = from_str(self.signed_data)
 692        return result
 693
 694
 695class SignedData:
 696    encoding_method: str
 697    encoding_method_version: Optional[int]
 698    public_key: Optional[str]
 699    signed_values: List[SignedValue]
 700    url: Optional[str]
 701
 702    def __init__(self, encoding_method: str, encoding_method_version: Optional[int], public_key: Optional[str], signed_values: List[SignedValue], url: Optional[str]) -> None:
 703        self.encoding_method = encoding_method
 704        self.encoding_method_version = encoding_method_version
 705        self.public_key = public_key
 706        self.signed_values = signed_values
 707        self.url = url
 708
 709    @staticmethod
 710    def from_dict(obj: Any) -> 'SignedData':
 711        assert isinstance(obj, dict)
 712        encoding_method = from_str(obj.get("encoding_method"))
 713        encoding_method_version = from_union([from_none, from_int], obj.get("encoding_method_version"))
 714        public_key = from_union([from_none, from_str], obj.get("public_key"))
 715        signed_values = from_list(SignedValue.from_dict, obj.get("signed_values"))
 716        url = from_union([from_none, from_str], obj.get("url"))
 717        return SignedData(encoding_method, encoding_method_version, public_key, signed_values, url)
 718
 719    def to_dict(self) -> dict:
 720        result: dict = {}
 721        result["encoding_method"] = from_str(self.encoding_method)
 722        if self.encoding_method_version is not None:
 723            result["encoding_method_version"] = from_union([from_none, from_int], self.encoding_method_version)
 724        if self.public_key is not None:
 725            result["public_key"] = from_union([from_none, from_str], self.public_key)
 726        result["signed_values"] = from_list(lambda x: to_class(SignedValue, x), self.signed_values)
 727        if self.url is not None:
 728            result["url"] = from_union([from_none, from_str], self.url)
 729        return result
 730
 731
 732class TariffDimensionType(Enum):
 733    ENERGY = "ENERGY"
 734    FLAT = "FLAT"
 735    PARKING_TIME = "PARKING_TIME"
 736    TIME = "TIME"
 737
 738
 739class PriceComponent:
 740    price: float
 741    step_size: int
 742    type: TariffDimensionType
 743    vat: Optional[float]
 744
 745    def __init__(self, price: float, step_size: int, type: TariffDimensionType, vat: Optional[float]) -> None:
 746        self.price = price
 747        self.step_size = step_size
 748        self.type = type
 749        self.vat = vat
 750
 751    @staticmethod
 752    def from_dict(obj: Any) -> 'PriceComponent':
 753        assert isinstance(obj, dict)
 754        price = from_float(obj.get("price"))
 755        step_size = from_int(obj.get("step_size"))
 756        type = TariffDimensionType(obj.get("type"))
 757        vat = from_union([from_none, from_float], obj.get("vat"))
 758        return PriceComponent(price, step_size, type, vat)
 759
 760    def to_dict(self) -> dict:
 761        result: dict = {}
 762        result["price"] = to_float(self.price)
 763        result["step_size"] = from_int(self.step_size)
 764        result["type"] = to_enum(TariffDimensionType, self.type)
 765        if self.vat is not None:
 766            result["vat"] = from_union([from_none, to_float], self.vat)
 767        return result
 768
 769
 770class DayOfWeek(Enum):
 771    FRIDAY = "FRIDAY"
 772    MONDAY = "MONDAY"
 773    SATURDAY = "SATURDAY"
 774    SUNDAY = "SUNDAY"
 775    THURSDAY = "THURSDAY"
 776    TUESDAY = "TUESDAY"
 777    WEDNESDAY = "WEDNESDAY"
 778
 779
 780class ReservationRestrictionType(Enum):
 781    RESERVATION = "RESERVATION"
 782    RESERVATION_EXPIRES = "RESERVATION_EXPIRES"
 783
 784
 785class TariffRestrictions:
 786    day_of_week: Optional[List[DayOfWeek]]
 787    end_date: Optional[str]
 788    end_time: Optional[str]
 789    max_current: Optional[float]
 790    max_duration: Optional[int]
 791    max_kwh: Optional[float]
 792    max_power: Optional[float]
 793    min_current: Optional[float]
 794    min_duration: Optional[int]
 795    min_kwh: Optional[float]
 796    min_power: Optional[float]
 797    reservation: Optional[ReservationRestrictionType]
 798    start_date: Optional[str]
 799    start_time: Optional[str]
 800
 801    def __init__(self, day_of_week: Optional[List[DayOfWeek]], end_date: Optional[str], end_time: Optional[str], max_current: Optional[float], max_duration: Optional[int], max_kwh: Optional[float], max_power: Optional[float], min_current: Optional[float], min_duration: Optional[int], min_kwh: Optional[float], min_power: Optional[float], reservation: Optional[ReservationRestrictionType], start_date: Optional[str], start_time: Optional[str]) -> None:
 802        self.day_of_week = day_of_week
 803        self.end_date = end_date
 804        self.end_time = end_time
 805        self.max_current = max_current
 806        self.max_duration = max_duration
 807        self.max_kwh = max_kwh
 808        self.max_power = max_power
 809        self.min_current = min_current
 810        self.min_duration = min_duration
 811        self.min_kwh = min_kwh
 812        self.min_power = min_power
 813        self.reservation = reservation
 814        self.start_date = start_date
 815        self.start_time = start_time
 816
 817    @staticmethod
 818    def from_dict(obj: Any) -> 'TariffRestrictions':
 819        assert isinstance(obj, dict)
 820        day_of_week = from_union([from_none, lambda x: from_list(DayOfWeek, x)], obj.get("day_of_week"))
 821        end_date = from_union([from_none, from_str], obj.get("end_date"))
 822        end_time = from_union([from_none, from_str], obj.get("end_time"))
 823        max_current = from_union([from_none, from_float], obj.get("max_current"))
 824        max_duration = from_union([from_none, from_int], obj.get("max_duration"))
 825        max_kwh = from_union([from_none, from_float], obj.get("max_kwh"))
 826        max_power = from_union([from_none, from_float], obj.get("max_power"))
 827        min_current = from_union([from_none, from_float], obj.get("min_current"))
 828        min_duration = from_union([from_none, from_int], obj.get("min_duration"))
 829        min_kwh = from_union([from_none, from_float], obj.get("min_kwh"))
 830        min_power = from_union([from_none, from_float], obj.get("min_power"))
 831        reservation = from_union([from_none, ReservationRestrictionType], obj.get("reservation"))
 832        start_date = from_union([from_none, from_str], obj.get("start_date"))
 833        start_time = from_union([from_none, from_str], obj.get("start_time"))
 834        return TariffRestrictions(day_of_week, end_date, end_time, max_current, max_duration, max_kwh, max_power, min_current, min_duration, min_kwh, min_power, reservation, start_date, start_time)
 835
 836    def to_dict(self) -> dict:
 837        result: dict = {}
 838        if self.day_of_week is not None:
 839            result["day_of_week"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(DayOfWeek, x), x)], self.day_of_week)
 840        if self.end_date is not None:
 841            result["end_date"] = from_union([from_none, from_str], self.end_date)
 842        if self.end_time is not None:
 843            result["end_time"] = from_union([from_none, from_str], self.end_time)
 844        if self.max_current is not None:
 845            result["max_current"] = from_union([from_none, to_float], self.max_current)
 846        if self.max_duration is not None:
 847            result["max_duration"] = from_union([from_none, from_int], self.max_duration)
 848        if self.max_kwh is not None:
 849            result["max_kwh"] = from_union([from_none, to_float], self.max_kwh)
 850        if self.max_power is not None:
 851            result["max_power"] = from_union([from_none, to_float], self.max_power)
 852        if self.min_current is not None:
 853            result["min_current"] = from_union([from_none, to_float], self.min_current)
 854        if self.min_duration is not None:
 855            result["min_duration"] = from_union([from_none, from_int], self.min_duration)
 856        if self.min_kwh is not None:
 857            result["min_kwh"] = from_union([from_none, to_float], self.min_kwh)
 858        if self.min_power is not None:
 859            result["min_power"] = from_union([from_none, to_float], self.min_power)
 860        if self.reservation is not None:
 861            result["reservation"] = from_union([from_none, lambda x: to_enum(ReservationRestrictionType, x)], self.reservation)
 862        if self.start_date is not None:
 863            result["start_date"] = from_union([from_none, from_str], self.start_date)
 864        if self.start_time is not None:
 865            result["start_time"] = from_union([from_none, from_str], self.start_time)
 866        return result
 867
 868
 869class TariffElement:
 870    price_components: List[PriceComponent]
 871    restrictions: Optional[TariffRestrictions]
 872
 873    def __init__(self, price_components: List[PriceComponent], restrictions: Optional[TariffRestrictions]) -> None:
 874        self.price_components = price_components
 875        self.restrictions = restrictions
 876
 877    @staticmethod
 878    def from_dict(obj: Any) -> 'TariffElement':
 879        assert isinstance(obj, dict)
 880        price_components = from_list(PriceComponent.from_dict, obj.get("price_components"))
 881        restrictions = from_union([from_none, TariffRestrictions.from_dict], obj.get("restrictions"))
 882        return TariffElement(price_components, restrictions)
 883
 884    def to_dict(self) -> dict:
 885        result: dict = {}
 886        result["price_components"] = from_list(lambda x: to_class(PriceComponent, x), self.price_components)
 887        if self.restrictions is not None:
 888            result["restrictions"] = from_union([from_none, lambda x: to_class(TariffRestrictions, x)], self.restrictions)
 889        return result
 890
 891
 892class EnergySourceCategory(Enum):
 893    COAL = "COAL"
 894    GAS = "GAS"
 895    GENERAL_FOSSIL = "GENERAL_FOSSIL"
 896    GENERAL_GREEN = "GENERAL_GREEN"
 897    NUCLEAR = "NUCLEAR"
 898    SOLAR = "SOLAR"
 899    WATER = "WATER"
 900    WIND = "WIND"
 901
 902
 903class EnergySource:
 904    percentage: float
 905    source: EnergySourceCategory
 906
 907    def __init__(self, percentage: float, source: EnergySourceCategory) -> None:
 908        self.percentage = percentage
 909        self.source = source
 910
 911    @staticmethod
 912    def from_dict(obj: Any) -> 'EnergySource':
 913        assert isinstance(obj, dict)
 914        percentage = from_float(obj.get("percentage"))
 915        source = EnergySourceCategory(obj.get("source"))
 916        return EnergySource(percentage, source)
 917
 918    def to_dict(self) -> dict:
 919        result: dict = {}
 920        result["percentage"] = to_float(self.percentage)
 921        result["source"] = to_enum(EnergySourceCategory, self.source)
 922        return result
 923
 924
 925class EnvironmentalImpactCategory(Enum):
 926    CARBON_DIOXIDE = "CARBON_DIOXIDE"
 927    NUCLEAR_WASTE = "NUCLEAR_WASTE"
 928
 929
 930class EnvironmentalImpact:
 931    amount: float
 932    category: EnvironmentalImpactCategory
 933
 934    def __init__(self, amount: float, category: EnvironmentalImpactCategory) -> None:
 935        self.amount = amount
 936        self.category = category
 937
 938    @staticmethod
 939    def from_dict(obj: Any) -> 'EnvironmentalImpact':
 940        assert isinstance(obj, dict)
 941        amount = from_float(obj.get("amount"))
 942        category = EnvironmentalImpactCategory(obj.get("category"))
 943        return EnvironmentalImpact(amount, category)
 944
 945    def to_dict(self) -> dict:
 946        result: dict = {}
 947        result["amount"] = to_float(self.amount)
 948        result["category"] = to_enum(EnvironmentalImpactCategory, self.category)
 949        return result
 950
 951
 952class EnergyMix:
 953    energy_product_name: Optional[str]
 954    energy_sources: Optional[List[EnergySource]]
 955    environ_impact: Optional[List[EnvironmentalImpact]]
 956    is_green_energy: bool
 957    supplier_name: Optional[str]
 958
 959    def __init__(self, energy_product_name: Optional[str], energy_sources: Optional[List[EnergySource]], environ_impact: Optional[List[EnvironmentalImpact]], is_green_energy: bool, supplier_name: Optional[str]) -> None:
 960        self.energy_product_name = energy_product_name
 961        self.energy_sources = energy_sources
 962        self.environ_impact = environ_impact
 963        self.is_green_energy = is_green_energy
 964        self.supplier_name = supplier_name
 965
 966    @staticmethod
 967    def from_dict(obj: Any) -> 'EnergyMix':
 968        assert isinstance(obj, dict)
 969        energy_product_name = from_union([from_none, from_str], obj.get("energy_product_name"))
 970        energy_sources = from_union([from_none, lambda x: from_list(EnergySource.from_dict, x)], obj.get("energy_sources"))
 971        environ_impact = from_union([from_none, lambda x: from_list(EnvironmentalImpact.from_dict, x)], obj.get("environ_impact"))
 972        is_green_energy = from_bool(obj.get("is_green_energy"))
 973        supplier_name = from_union([from_none, from_str], obj.get("supplier_name"))
 974        return EnergyMix(energy_product_name, energy_sources, environ_impact, is_green_energy, supplier_name)
 975
 976    def to_dict(self) -> dict:
 977        result: dict = {}
 978        if self.energy_product_name is not None:
 979            result["energy_product_name"] = from_union([from_none, from_str], self.energy_product_name)
 980        if self.energy_sources is not None:
 981            result["energy_sources"] = from_union([from_none, lambda x: from_list(lambda x: to_class(EnergySource, x), x)], self.energy_sources)
 982        if self.environ_impact is not None:
 983            result["environ_impact"] = from_union([from_none, lambda x: from_list(lambda x: to_class(EnvironmentalImpact, x), x)], self.environ_impact)
 984        result["is_green_energy"] = from_bool(self.is_green_energy)
 985        if self.supplier_name is not None:
 986            result["supplier_name"] = from_union([from_none, from_str], self.supplier_name)
 987        return result
 988
 989
 990class PriceLimit:
 991    after_taxes: Optional[float]
 992    before_taxes: float
 993
 994    def __init__(self, after_taxes: Optional[float], before_taxes: float) -> None:
 995        self.after_taxes = after_taxes
 996        self.before_taxes = before_taxes
 997
 998    @staticmethod
 999    def from_dict(obj: Any) -> 'PriceLimit':
1000        assert isinstance(obj, dict)
1001        after_taxes = from_union([from_none, from_float], obj.get("after_taxes"))
1002        before_taxes = from_float(obj.get("before_taxes"))
1003        return PriceLimit(after_taxes, before_taxes)
1004
1005    def to_dict(self) -> dict:
1006        result: dict = {}
1007        if self.after_taxes is not None:
1008            result["after_taxes"] = from_union([from_none, to_float], self.after_taxes)
1009        result["before_taxes"] = to_float(self.before_taxes)
1010        return result
1011
1012
1013class TaxIncluded(Enum):
1014    NO = "NO"
1015    N_A = "N/A"
1016    YES = "YES"
1017
1018
1019class TariffType(Enum):
1020    AD_HOC_PAYMENT = "AD_HOC_PAYMENT"
1021    PROFILE_CHEAP = "PROFILE_CHEAP"
1022    PROFILE_FAST = "PROFILE_FAST"
1023    PROFILE_GREEN = "PROFILE_GREEN"
1024    REGULAR = "REGULAR"
1025
1026
1027class Tariff:
1028    country_code: str
1029    currency: str
1030    elements: List[TariffElement]
1031    end_date_time: Optional[str]
1032    energy_mix: Optional[EnergyMix]
1033    id: str
1034    last_updated: str
1035    max_price: Optional[PriceLimit]
1036    min_price: Optional[PriceLimit]
1037    party_id: str
1038    start_date_time: Optional[str]
1039    tariff_alt_text: Optional[List[DisplayText]]
1040    tariff_alt_url: Optional[str]
1041    tax_included: TaxIncluded
1042    type: Optional[TariffType]
1043
1044    def __init__(self, country_code: str, currency: str, elements: List[TariffElement], end_date_time: Optional[str], energy_mix: Optional[EnergyMix], id: str, last_updated: str, max_price: Optional[PriceLimit], min_price: Optional[PriceLimit], party_id: str, start_date_time: Optional[str], tariff_alt_text: Optional[List[DisplayText]], tariff_alt_url: Optional[str], tax_included: TaxIncluded, type: Optional[TariffType]) -> None:
1045        self.country_code = country_code
1046        self.currency = currency
1047        self.elements = elements
1048        self.end_date_time = end_date_time
1049        self.energy_mix = energy_mix
1050        self.id = id
1051        self.last_updated = last_updated
1052        self.max_price = max_price
1053        self.min_price = min_price
1054        self.party_id = party_id
1055        self.start_date_time = start_date_time
1056        self.tariff_alt_text = tariff_alt_text
1057        self.tariff_alt_url = tariff_alt_url
1058        self.tax_included = tax_included
1059        self.type = type
1060
1061    @staticmethod
1062    def from_dict(obj: Any) -> 'Tariff':
1063        assert isinstance(obj, dict)
1064        country_code = from_str(obj.get("country_code"))
1065        currency = from_str(obj.get("currency"))
1066        elements = from_list(TariffElement.from_dict, obj.get("elements"))
1067        end_date_time = from_union([from_none, from_str], obj.get("end_date_time"))
1068        energy_mix = from_union([from_none, EnergyMix.from_dict], obj.get("energy_mix"))
1069        id = from_str(obj.get("id"))
1070        last_updated = from_str(obj.get("last_updated"))
1071        max_price = from_union([from_none, PriceLimit.from_dict], obj.get("max_price"))
1072        min_price = from_union([from_none, PriceLimit.from_dict], obj.get("min_price"))
1073        party_id = from_str(obj.get("party_id"))
1074        start_date_time = from_union([from_none, from_str], obj.get("start_date_time"))
1075        tariff_alt_text = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("tariff_alt_text"))
1076        tariff_alt_url = from_union([from_none, from_str], obj.get("tariff_alt_url"))
1077        tax_included = TaxIncluded(obj.get("tax_included"))
1078        type = from_union([from_none, TariffType], obj.get("type"))
1079        return Tariff(country_code, currency, elements, end_date_time, energy_mix, id, last_updated, max_price, min_price, party_id, start_date_time, tariff_alt_text, tariff_alt_url, tax_included, type)
1080
1081    def to_dict(self) -> dict:
1082        result: dict = {}
1083        result["country_code"] = from_str(self.country_code)
1084        result["currency"] = from_str(self.currency)
1085        result["elements"] = from_list(lambda x: to_class(TariffElement, x), self.elements)
1086        if self.end_date_time is not None:
1087            result["end_date_time"] = from_union([from_none, from_str], self.end_date_time)
1088        if self.energy_mix is not None:
1089            result["energy_mix"] = from_union([from_none, lambda x: to_class(EnergyMix, x)], self.energy_mix)
1090        result["id"] = from_str(self.id)
1091        result["last_updated"] = from_str(self.last_updated)
1092        if self.max_price is not None:
1093            result["max_price"] = from_union([from_none, lambda x: to_class(PriceLimit, x)], self.max_price)
1094        if self.min_price is not None:
1095            result["min_price"] = from_union([from_none, lambda x: to_class(PriceLimit, x)], self.min_price)
1096        result["party_id"] = from_str(self.party_id)
1097        if self.start_date_time is not None:
1098            result["start_date_time"] = from_union([from_none, from_str], self.start_date_time)
1099        if self.tariff_alt_text is not None:
1100            result["tariff_alt_text"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.tariff_alt_text)
1101        if self.tariff_alt_url is not None:
1102            result["tariff_alt_url"] = from_union([from_none, from_str], self.tariff_alt_url)
1103        result["tax_included"] = to_enum(TaxIncluded, self.tax_included)
1104        if self.type is not None:
1105            result["type"] = from_union([from_none, lambda x: to_enum(TariffType, x)], self.type)
1106        return result
1107
1108
1109class TaxAmount:
1110    account_number: Optional[str]
1111    amount: float
1112    name: str
1113    percentage: Optional[float]
1114
1115    def __init__(self, account_number: Optional[str], amount: float, name: str, percentage: Optional[float]) -> None:
1116        self.account_number = account_number
1117        self.amount = amount
1118        self.name = name
1119        self.percentage = percentage
1120
1121    @staticmethod
1122    def from_dict(obj: Any) -> 'TaxAmount':
1123        assert isinstance(obj, dict)
1124        account_number = from_union([from_none, from_str], obj.get("account_number"))
1125        amount = from_float(obj.get("amount"))
1126        name = from_str(obj.get("name"))
1127        percentage = from_union([from_none, from_float], obj.get("percentage"))
1128        return TaxAmount(account_number, amount, name, percentage)
1129
1130    def to_dict(self) -> dict:
1131        result: dict = {}
1132        if self.account_number is not None:
1133            result["account_number"] = from_union([from_none, from_str], self.account_number)
1134        result["amount"] = to_float(self.amount)
1135        result["name"] = from_str(self.name)
1136        if self.percentage is not None:
1137            result["percentage"] = from_union([from_none, to_float], self.percentage)
1138        return result
1139
1140
1141class Price:
1142    before_taxes: float
1143    taxes: Optional[List[TaxAmount]]
1144
1145    def __init__(self, before_taxes: float, taxes: Optional[List[TaxAmount]]) -> None:
1146        self.before_taxes = before_taxes
1147        self.taxes = taxes
1148
1149    @staticmethod
1150    def from_dict(obj: Any) -> 'Price':
1151        assert isinstance(obj, dict)
1152        before_taxes = from_float(obj.get("before_taxes"))
1153        taxes = from_union([from_none, lambda x: from_list(TaxAmount.from_dict, x)], obj.get("taxes"))
1154        return Price(before_taxes, taxes)
1155
1156    def to_dict(self) -> dict:
1157        result: dict = {}
1158        result["before_taxes"] = to_float(self.before_taxes)
1159        if self.taxes is not None:
1160            result["taxes"] = from_union([from_none, lambda x: from_list(lambda x: to_class(TaxAmount, x), x)], self.taxes)
1161        return result
1162
1163
1164class Cdr:
1165    auth_method: AuthMethod
1166    authorization_reference: Optional[str]
1167    cdr_location: CdrLocation
1168    cdr_token: CdrToken
1169    charging_periods: List[ChargingPeriod]
1170    country_code: str
1171    credit: Optional[bool]
1172    credit_reference_id: Optional[str]
1173    currency: str
1174    end_date_time: str
1175    home_charging_compensation: Optional[bool]
1176    id: str
1177    invoice_reference_id: Optional[str]
1178    last_updated: str
1179    meter_id: Optional[str]
1180    party_id: str
1181    remark: Optional[str]
1182    session_id: Optional[str]
1183    signed_data: Optional[SignedData]
1184    start_date_time: str
1185    tariffs: Optional[List[Tariff]]
1186    total_cost: Price
1187    total_energy: float
1188    total_energy_cost: Optional[Price]
1189    total_fixed_cost: Optional[Price]
1190    total_parking_cost: Optional[Price]
1191    total_parking_time: Optional[float]
1192    total_reservation_cost: Optional[Price]
1193    total_time: float
1194    total_time_cost: Optional[Price]
1195
1196    def __init__(self, auth_method: AuthMethod, authorization_reference: Optional[str], cdr_location: CdrLocation, cdr_token: CdrToken, charging_periods: List[ChargingPeriod], country_code: str, credit: Optional[bool], credit_reference_id: Optional[str], currency: str, end_date_time: str, home_charging_compensation: Optional[bool], id: str, invoice_reference_id: Optional[str], last_updated: str, meter_id: Optional[str], party_id: str, remark: Optional[str], session_id: Optional[str], signed_data: Optional[SignedData], start_date_time: str, tariffs: Optional[List[Tariff]], total_cost: Price, total_energy: float, total_energy_cost: Optional[Price], total_fixed_cost: Optional[Price], total_parking_cost: Optional[Price], total_parking_time: Optional[float], total_reservation_cost: Optional[Price], total_time: float, total_time_cost: Optional[Price]) -> None:
1197        self.auth_method = auth_method
1198        self.authorization_reference = authorization_reference
1199        self.cdr_location = cdr_location
1200        self.cdr_token = cdr_token
1201        self.charging_periods = charging_periods
1202        self.country_code = country_code
1203        self.credit = credit
1204        self.credit_reference_id = credit_reference_id
1205        self.currency = currency
1206        self.end_date_time = end_date_time
1207        self.home_charging_compensation = home_charging_compensation
1208        self.id = id
1209        self.invoice_reference_id = invoice_reference_id
1210        self.last_updated = last_updated
1211        self.meter_id = meter_id
1212        self.party_id = party_id
1213        self.remark = remark
1214        self.session_id = session_id
1215        self.signed_data = signed_data
1216        self.start_date_time = start_date_time
1217        self.tariffs = tariffs
1218        self.total_cost = total_cost
1219        self.total_energy = total_energy
1220        self.total_energy_cost = total_energy_cost
1221        self.total_fixed_cost = total_fixed_cost
1222        self.total_parking_cost = total_parking_cost
1223        self.total_parking_time = total_parking_time
1224        self.total_reservation_cost = total_reservation_cost
1225        self.total_time = total_time
1226        self.total_time_cost = total_time_cost
1227
1228    @staticmethod
1229    def from_dict(obj: Any) -> 'Cdr':
1230        assert isinstance(obj, dict)
1231        auth_method = AuthMethod(obj.get("auth_method"))
1232        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
1233        cdr_location = CdrLocation.from_dict(obj.get("cdr_location"))
1234        cdr_token = CdrToken.from_dict(obj.get("cdr_token"))
1235        charging_periods = from_list(ChargingPeriod.from_dict, obj.get("charging_periods"))
1236        country_code = from_str(obj.get("country_code"))
1237        credit = from_union([from_none, from_bool], obj.get("credit"))
1238        credit_reference_id = from_union([from_none, from_str], obj.get("credit_reference_id"))
1239        currency = from_str(obj.get("currency"))
1240        end_date_time = from_str(obj.get("end_date_time"))
1241        home_charging_compensation = from_union([from_none, from_bool], obj.get("home_charging_compensation"))
1242        id = from_str(obj.get("id"))
1243        invoice_reference_id = from_union([from_none, from_str], obj.get("invoice_reference_id"))
1244        last_updated = from_str(obj.get("last_updated"))
1245        meter_id = from_union([from_none, from_str], obj.get("meter_id"))
1246        party_id = from_str(obj.get("party_id"))
1247        remark = from_union([from_none, from_str], obj.get("remark"))
1248        session_id = from_union([from_none, from_str], obj.get("session_id"))
1249        signed_data = from_union([from_none, SignedData.from_dict], obj.get("signed_data"))
1250        start_date_time = from_str(obj.get("start_date_time"))
1251        tariffs = from_union([from_none, lambda x: from_list(Tariff.from_dict, x)], obj.get("tariffs"))
1252        total_cost = Price.from_dict(obj.get("total_cost"))
1253        total_energy = from_float(obj.get("total_energy"))
1254        total_energy_cost = from_union([from_none, Price.from_dict], obj.get("total_energy_cost"))
1255        total_fixed_cost = from_union([from_none, Price.from_dict], obj.get("total_fixed_cost"))
1256        total_parking_cost = from_union([from_none, Price.from_dict], obj.get("total_parking_cost"))
1257        total_parking_time = from_union([from_none, from_float], obj.get("total_parking_time"))
1258        total_reservation_cost = from_union([from_none, Price.from_dict], obj.get("total_reservation_cost"))
1259        total_time = from_float(obj.get("total_time"))
1260        total_time_cost = from_union([from_none, Price.from_dict], obj.get("total_time_cost"))
1261        return Cdr(auth_method, authorization_reference, cdr_location, cdr_token, charging_periods, country_code, credit, credit_reference_id, currency, end_date_time, home_charging_compensation, id, invoice_reference_id, last_updated, meter_id, party_id, remark, session_id, signed_data, start_date_time, tariffs, total_cost, total_energy, total_energy_cost, total_fixed_cost, total_parking_cost, total_parking_time, total_reservation_cost, total_time, total_time_cost)
1262
1263    def to_dict(self) -> dict:
1264        result: dict = {}
1265        result["auth_method"] = to_enum(AuthMethod, self.auth_method)
1266        if self.authorization_reference is not None:
1267            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
1268        result["cdr_location"] = to_class(CdrLocation, self.cdr_location)
1269        result["cdr_token"] = to_class(CdrToken, self.cdr_token)
1270        result["charging_periods"] = from_list(lambda x: to_class(ChargingPeriod, x), self.charging_periods)
1271        result["country_code"] = from_str(self.country_code)
1272        if self.credit is not None:
1273            result["credit"] = from_union([from_none, from_bool], self.credit)
1274        if self.credit_reference_id is not None:
1275            result["credit_reference_id"] = from_union([from_none, from_str], self.credit_reference_id)
1276        result["currency"] = from_str(self.currency)
1277        result["end_date_time"] = from_str(self.end_date_time)
1278        if self.home_charging_compensation is not None:
1279            result["home_charging_compensation"] = from_union([from_none, from_bool], self.home_charging_compensation)
1280        result["id"] = from_str(self.id)
1281        if self.invoice_reference_id is not None:
1282            result["invoice_reference_id"] = from_union([from_none, from_str], self.invoice_reference_id)
1283        result["last_updated"] = from_str(self.last_updated)
1284        if self.meter_id is not None:
1285            result["meter_id"] = from_union([from_none, from_str], self.meter_id)
1286        result["party_id"] = from_str(self.party_id)
1287        if self.remark is not None:
1288            result["remark"] = from_union([from_none, from_str], self.remark)
1289        if self.session_id is not None:
1290            result["session_id"] = from_union([from_none, from_str], self.session_id)
1291        if self.signed_data is not None:
1292            result["signed_data"] = from_union([from_none, lambda x: to_class(SignedData, x)], self.signed_data)
1293        result["start_date_time"] = from_str(self.start_date_time)
1294        if self.tariffs is not None:
1295            result["tariffs"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Tariff, x), x)], self.tariffs)
1296        result["total_cost"] = to_class(Price, self.total_cost)
1297        result["total_energy"] = to_float(self.total_energy)
1298        if self.total_energy_cost is not None:
1299            result["total_energy_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_energy_cost)
1300        if self.total_fixed_cost is not None:
1301            result["total_fixed_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_fixed_cost)
1302        if self.total_parking_cost is not None:
1303            result["total_parking_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_parking_cost)
1304        if self.total_parking_time is not None:
1305            result["total_parking_time"] = from_union([from_none, to_float], self.total_parking_time)
1306        if self.total_reservation_cost is not None:
1307            result["total_reservation_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_reservation_cost)
1308        result["total_time"] = to_float(self.total_time)
1309        if self.total_time_cost is not None:
1310            result["total_time_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_time_cost)
1311        return result
1312
1313
1314class ChargingPreferences:
1315    departure_time: Optional[str]
1316    discharge_allowed: Optional[bool]
1317    energy_need: Optional[float]
1318    profile_type: ProfileType
1319
1320    def __init__(self, departure_time: Optional[str], discharge_allowed: Optional[bool], energy_need: Optional[float], profile_type: ProfileType) -> None:
1321        self.departure_time = departure_time
1322        self.discharge_allowed = discharge_allowed
1323        self.energy_need = energy_need
1324        self.profile_type = profile_type
1325
1326    @staticmethod
1327    def from_dict(obj: Any) -> 'ChargingPreferences':
1328        assert isinstance(obj, dict)
1329        departure_time = from_union([from_none, from_str], obj.get("departure_time"))
1330        discharge_allowed = from_union([from_none, from_bool], obj.get("discharge_allowed"))
1331        energy_need = from_union([from_none, from_float], obj.get("energy_need"))
1332        profile_type = ProfileType(obj.get("profile_type"))
1333        return ChargingPreferences(departure_time, discharge_allowed, energy_need, profile_type)
1334
1335    def to_dict(self) -> dict:
1336        result: dict = {}
1337        if self.departure_time is not None:
1338            result["departure_time"] = from_union([from_none, from_str], self.departure_time)
1339        if self.discharge_allowed is not None:
1340            result["discharge_allowed"] = from_union([from_none, from_bool], self.discharge_allowed)
1341        if self.energy_need is not None:
1342            result["energy_need"] = from_union([from_none, to_float], self.energy_need)
1343        result["profile_type"] = to_enum(ProfileType, self.profile_type)
1344        return result
1345
1346
1347class ChargingProfileResponseType(Enum):
1348    ACCEPTED = "ACCEPTED"
1349    NOT_SUPPORTED = "NOT_SUPPORTED"
1350    REJECTED = "REJECTED"
1351    TOO_OFTEN = "TOO_OFTEN"
1352    UNKNOWN_SESSION = "UNKNOWN_SESSION"
1353
1354
1355class ChargingProfileResponse:
1356    result: ChargingProfileResponseType
1357    timeout: int
1358
1359    def __init__(self, result: ChargingProfileResponseType, timeout: int) -> None:
1360        self.result = result
1361        self.timeout = timeout
1362
1363    @staticmethod
1364    def from_dict(obj: Any) -> 'ChargingProfileResponse':
1365        assert isinstance(obj, dict)
1366        result = ChargingProfileResponseType(obj.get("result"))
1367        timeout = from_int(obj.get("timeout"))
1368        return ChargingProfileResponse(result, timeout)
1369
1370    def to_dict(self) -> dict:
1371        result: dict = {}
1372        result["result"] = to_enum(ChargingProfileResponseType, self.result)
1373        result["timeout"] = from_int(self.timeout)
1374        return result
1375
1376
1377class ChargingProfileResult:
1378    result: ChargingProfileResultType
1379
1380    def __init__(self, result: ChargingProfileResultType) -> None:
1381        self.result = result
1382
1383    @staticmethod
1384    def from_dict(obj: Any) -> 'ChargingProfileResult':
1385        assert isinstance(obj, dict)
1386        result = ChargingProfileResultType(obj.get("result"))
1387        return ChargingProfileResult(result)
1388
1389    def to_dict(self) -> dict:
1390        result: dict = {}
1391        result["result"] = to_enum(ChargingProfileResultType, self.result)
1392        return result
1393
1394
1395class ClearProfileResult:
1396    result: ChargingProfileResultType
1397
1398    def __init__(self, result: ChargingProfileResultType) -> None:
1399        self.result = result
1400
1401    @staticmethod
1402    def from_dict(obj: Any) -> 'ClearProfileResult':
1403        assert isinstance(obj, dict)
1404        result = ChargingProfileResultType(obj.get("result"))
1405        return ClearProfileResult(result)
1406
1407    def to_dict(self) -> dict:
1408        result: dict = {}
1409        result["result"] = to_enum(ChargingProfileResultType, self.result)
1410        return result
1411
1412
1413class CommandResponseType(Enum):
1414    ACCEPTED = "ACCEPTED"
1415    NOT_SUPPORTED = "NOT_SUPPORTED"
1416    REJECTED = "REJECTED"
1417    UNKNOWN_SESSION = "UNKNOWN_SESSION"
1418
1419
1420class CommandResponse:
1421    message: Optional[List[DisplayText]]
1422    result: CommandResponseType
1423    timeout: int
1424
1425    def __init__(self, message: Optional[List[DisplayText]], result: CommandResponseType, timeout: int) -> None:
1426        self.message = message
1427        self.result = result
1428        self.timeout = timeout
1429
1430    @staticmethod
1431    def from_dict(obj: Any) -> 'CommandResponse':
1432        assert isinstance(obj, dict)
1433        message = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("message"))
1434        result = CommandResponseType(obj.get("result"))
1435        timeout = from_int(obj.get("timeout"))
1436        return CommandResponse(message, result, timeout)
1437
1438    def to_dict(self) -> dict:
1439        result: dict = {}
1440        if self.message is not None:
1441            result["message"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.message)
1442        result["result"] = to_enum(CommandResponseType, self.result)
1443        result["timeout"] = from_int(self.timeout)
1444        return result
1445
1446
1447class CommandResultType(Enum):
1448    ACCEPTED = "ACCEPTED"
1449    CANCELED_RESERVATION = "CANCELED_RESERVATION"
1450    EVSE_INOPERATIVE = "EVSE_INOPERATIVE"
1451    EVSE_OCCUPIED = "EVSE_OCCUPIED"
1452    FAILED = "FAILED"
1453    NOT_SUPPORTED = "NOT_SUPPORTED"
1454    REJECTED = "REJECTED"
1455    TIMEOUT = "TIMEOUT"
1456    UNKNOWN_RESERVATION = "UNKNOWN_RESERVATION"
1457
1458
1459class CommandResult:
1460    message: Optional[List[DisplayText]]
1461    result: CommandResultType
1462
1463    def __init__(self, message: Optional[List[DisplayText]], result: CommandResultType) -> None:
1464        self.message = message
1465        self.result = result
1466
1467    @staticmethod
1468    def from_dict(obj: Any) -> 'CommandResult':
1469        assert isinstance(obj, dict)
1470        message = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("message"))
1471        result = CommandResultType(obj.get("result"))
1472        return CommandResult(message, result)
1473
1474    def to_dict(self) -> dict:
1475        result: dict = {}
1476        if self.message is not None:
1477            result["message"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.message)
1478        result["result"] = to_enum(CommandResultType, self.result)
1479        return result
1480
1481
1482class ConnectorCapability(Enum):
1483    ISO_15118_20__PLUG_AND_CHARGE = "ISO_15118_20_PLUG_AND_CHARGE"
1484    ISO_15118_2__PLUG_AND_CHARGE = "ISO_15118_2_PLUG_AND_CHARGE"
1485
1486
1487class Connector:
1488    capabilities: Optional[List[ConnectorCapability]]
1489    format: ConnectorFormat
1490    id: str
1491    last_updated: str
1492    max_amperage: int
1493    max_electric_power: Optional[int]
1494    max_voltage: int
1495    power_type: PowerType
1496    standard: ConnectorType
1497    tariff_ids: Optional[List[str]]
1498    terms_and_conditions: Optional[str]
1499
1500    def __init__(self, capabilities: Optional[List[ConnectorCapability]], format: ConnectorFormat, id: str, last_updated: str, max_amperage: int, max_electric_power: Optional[int], max_voltage: int, power_type: PowerType, standard: ConnectorType, tariff_ids: Optional[List[str]], terms_and_conditions: Optional[str]) -> None:
1501        self.capabilities = capabilities
1502        self.format = format
1503        self.id = id
1504        self.last_updated = last_updated
1505        self.max_amperage = max_amperage
1506        self.max_electric_power = max_electric_power
1507        self.max_voltage = max_voltage
1508        self.power_type = power_type
1509        self.standard = standard
1510        self.tariff_ids = tariff_ids
1511        self.terms_and_conditions = terms_and_conditions
1512
1513    @staticmethod
1514    def from_dict(obj: Any) -> 'Connector':
1515        assert isinstance(obj, dict)
1516        capabilities = from_union([from_none, lambda x: from_list(ConnectorCapability, x)], obj.get("capabilities"))
1517        format = ConnectorFormat(obj.get("format"))
1518        id = from_str(obj.get("id"))
1519        last_updated = from_str(obj.get("last_updated"))
1520        max_amperage = from_int(obj.get("max_amperage"))
1521        max_electric_power = from_union([from_none, from_int], obj.get("max_electric_power"))
1522        max_voltage = from_int(obj.get("max_voltage"))
1523        power_type = PowerType(obj.get("power_type"))
1524        standard = ConnectorType(obj.get("standard"))
1525        tariff_ids = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("tariff_ids"))
1526        terms_and_conditions = from_union([from_none, from_str], obj.get("terms_and_conditions"))
1527        return Connector(capabilities, format, id, last_updated, max_amperage, max_electric_power, max_voltage, power_type, standard, tariff_ids, terms_and_conditions)
1528
1529    def to_dict(self) -> dict:
1530        result: dict = {}
1531        if self.capabilities is not None:
1532            result["capabilities"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(ConnectorCapability, x), x)], self.capabilities)
1533        result["format"] = to_enum(ConnectorFormat, self.format)
1534        result["id"] = from_str(self.id)
1535        result["last_updated"] = from_str(self.last_updated)
1536        result["max_amperage"] = from_int(self.max_amperage)
1537        if self.max_electric_power is not None:
1538            result["max_electric_power"] = from_union([from_none, from_int], self.max_electric_power)
1539        result["max_voltage"] = from_int(self.max_voltage)
1540        result["power_type"] = to_enum(PowerType, self.power_type)
1541        result["standard"] = to_enum(ConnectorType, self.standard)
1542        if self.tariff_ids is not None:
1543            result["tariff_ids"] = from_union([from_none, lambda x: from_list(from_str, x)], self.tariff_ids)
1544        if self.terms_and_conditions is not None:
1545            result["terms_and_conditions"] = from_union([from_none, from_str], self.terms_and_conditions)
1546        return result
1547
1548
1549class ImageCategory(Enum):
1550    CHARGER = "CHARGER"
1551    ENTRANCE = "ENTRANCE"
1552    LOCATION = "LOCATION"
1553    NETWORK = "NETWORK"
1554    OPERATOR = "OPERATOR"
1555    OTHER = "OTHER"
1556    OWNER = "OWNER"
1557
1558
1559class Image:
1560    category: ImageCategory
1561    height: Optional[int]
1562    thumbnail: Optional[str]
1563    type: str
1564    url: str
1565    width: Optional[int]
1566
1567    def __init__(self, category: ImageCategory, height: Optional[int], thumbnail: Optional[str], type: str, url: str, width: Optional[int]) -> None:
1568        self.category = category
1569        self.height = height
1570        self.thumbnail = thumbnail
1571        self.type = type
1572        self.url = url
1573        self.width = width
1574
1575    @staticmethod
1576    def from_dict(obj: Any) -> 'Image':
1577        assert isinstance(obj, dict)
1578        category = ImageCategory(obj.get("category"))
1579        height = from_union([from_none, from_int], obj.get("height"))
1580        thumbnail = from_union([from_none, from_str], obj.get("thumbnail"))
1581        type = from_str(obj.get("type"))
1582        url = from_str(obj.get("url"))
1583        width = from_union([from_none, from_int], obj.get("width"))
1584        return Image(category, height, thumbnail, type, url, width)
1585
1586    def to_dict(self) -> dict:
1587        result: dict = {}
1588        result["category"] = to_enum(ImageCategory, self.category)
1589        if self.height is not None:
1590            result["height"] = from_union([from_none, from_int], self.height)
1591        if self.thumbnail is not None:
1592            result["thumbnail"] = from_union([from_none, from_str], self.thumbnail)
1593        result["type"] = from_str(self.type)
1594        result["url"] = from_str(self.url)
1595        if self.width is not None:
1596            result["width"] = from_union([from_none, from_int], self.width)
1597        return result
1598
1599
1600class BusinessDetails:
1601    logo: Optional[Image]
1602    name: str
1603    website: Optional[str]
1604
1605    def __init__(self, logo: Optional[Image], name: str, website: Optional[str]) -> None:
1606        self.logo = logo
1607        self.name = name
1608        self.website = website
1609
1610    @staticmethod
1611    def from_dict(obj: Any) -> 'BusinessDetails':
1612        assert isinstance(obj, dict)
1613        logo = from_union([from_none, Image.from_dict], obj.get("logo"))
1614        name = from_str(obj.get("name"))
1615        website = from_union([from_none, from_str], obj.get("website"))
1616        return BusinessDetails(logo, name, website)
1617
1618    def to_dict(self) -> dict:
1619        result: dict = {}
1620        if self.logo is not None:
1621            result["logo"] = from_union([from_none, lambda x: to_class(Image, x)], self.logo)
1622        result["name"] = from_str(self.name)
1623        if self.website is not None:
1624            result["website"] = from_union([from_none, from_str], self.website)
1625        return result
1626
1627
1628class Role(Enum):
1629    CPO = "CPO"
1630    EMSP = "EMSP"
1631    NAP = "NAP"
1632    NSP = "NSP"
1633    OTHER = "OTHER"
1634    SCSP = "SCSP"
1635
1636
1637class CredentialsRole:
1638    business_details: BusinessDetails
1639    country_code: str
1640    party_id: str
1641    role: Role
1642
1643    def __init__(self, business_details: BusinessDetails, country_code: str, party_id: str, role: Role) -> None:
1644        self.business_details = business_details
1645        self.country_code = country_code
1646        self.party_id = party_id
1647        self.role = role
1648
1649    @staticmethod
1650    def from_dict(obj: Any) -> 'CredentialsRole':
1651        assert isinstance(obj, dict)
1652        business_details = BusinessDetails.from_dict(obj.get("business_details"))
1653        country_code = from_str(obj.get("country_code"))
1654        party_id = from_str(obj.get("party_id"))
1655        role = Role(obj.get("role"))
1656        return CredentialsRole(business_details, country_code, party_id, role)
1657
1658    def to_dict(self) -> dict:
1659        result: dict = {}
1660        result["business_details"] = to_class(BusinessDetails, self.business_details)
1661        result["country_code"] = from_str(self.country_code)
1662        result["party_id"] = from_str(self.party_id)
1663        result["role"] = to_enum(Role, self.role)
1664        return result
1665
1666
1667class Credentials:
1668    hub_party_id: Optional[str]
1669    roles: List[CredentialsRole]
1670    token: str
1671    url: str
1672
1673    def __init__(self, hub_party_id: Optional[str], roles: List[CredentialsRole], token: str, url: str) -> None:
1674        self.hub_party_id = hub_party_id
1675        self.roles = roles
1676        self.token = token
1677        self.url = url
1678
1679    @staticmethod
1680    def from_dict(obj: Any) -> 'Credentials':
1681        assert isinstance(obj, dict)
1682        hub_party_id = from_union([from_none, from_str], obj.get("hub_party_id"))
1683        roles = from_list(CredentialsRole.from_dict, obj.get("roles"))
1684        token = from_str(obj.get("token"))
1685        url = from_str(obj.get("url"))
1686        return Credentials(hub_party_id, roles, token, url)
1687
1688    def to_dict(self) -> dict:
1689        result: dict = {}
1690        if self.hub_party_id is not None:
1691            result["hub_party_id"] = from_union([from_none, from_str], self.hub_party_id)
1692        result["roles"] = from_list(lambda x: to_class(CredentialsRole, x), self.roles)
1693        result["token"] = from_str(self.token)
1694        result["url"] = from_str(self.url)
1695        return result
1696
1697
1698class ModuleID(Enum):
1699    CDRS = "cdrs"
1700    CHARGINGPROFILES = "chargingprofiles"
1701    COMMANDS = "commands"
1702    CREDENTIALS = "credentials"
1703    HUBCLIENTINFO = "hubclientinfo"
1704    LOCATIONS = "locations"
1705    SESSIONS = "sessions"
1706    TARIFFS = "tariffs"
1707    TOKENS = "tokens"
1708
1709
1710class InterfaceRole(Enum):
1711    RECEIVER = "RECEIVER"
1712    SENDER = "SENDER"
1713
1714
1715class Endpoint:
1716    identifier: ModuleID
1717    role: InterfaceRole
1718    url: str
1719
1720    def __init__(self, identifier: ModuleID, role: InterfaceRole, url: str) -> None:
1721        self.identifier = identifier
1722        self.role = role
1723        self.url = url
1724
1725    @staticmethod
1726    def from_dict(obj: Any) -> 'Endpoint':
1727        assert isinstance(obj, dict)
1728        identifier = ModuleID(obj.get("identifier"))
1729        role = InterfaceRole(obj.get("role"))
1730        url = from_str(obj.get("url"))
1731        return Endpoint(identifier, role, url)
1732
1733    def to_dict(self) -> dict:
1734        result: dict = {}
1735        result["identifier"] = to_enum(ModuleID, self.identifier)
1736        result["role"] = to_enum(InterfaceRole, self.role)
1737        result["url"] = from_str(self.url)
1738        return result
1739
1740
1741class Capability(Enum):
1742    CHARGING_PREFERENCES_CAPABLE = "CHARGING_PREFERENCES_CAPABLE"
1743    CHARGING_PROFILE_CAPABLE = "CHARGING_PROFILE_CAPABLE"
1744    CHIP_CARD_SUPPORT = "CHIP_CARD_SUPPORT"
1745    CONTACTLESS_CARD_SUPPORT = "CONTACTLESS_CARD_SUPPORT"
1746    CREDIT_CARD_PAYABLE = "CREDIT_CARD_PAYABLE"
1747    DEBIT_CARD_PAYABLE = "DEBIT_CARD_PAYABLE"
1748    PED_TERMINAL = "PED_TERMINAL"
1749    REMOTE_START_STOP_CAPABLE = "REMOTE_START_STOP_CAPABLE"
1750    RESERVABLE = "RESERVABLE"
1751    RFID_READER = "RFID_READER"
1752    START_SESSION_CONNECTOR_REQUIRED = "START_SESSION_CONNECTOR_REQUIRED"
1753    TOKEN_GROUP_CAPABLE = "TOKEN_GROUP_CAPABLE"
1754    UNLOCK_CAPABLE = "UNLOCK_CAPABLE"
1755
1756
1757class EvsePosition(Enum):
1758    CENTER = "CENTER"
1759    LEFT = "LEFT"
1760    RIGHT = "RIGHT"
1761
1762
1763class EvseParking:
1764    evse_position: Optional[EvsePosition]
1765    parking_id: str
1766
1767    def __init__(self, evse_position: Optional[EvsePosition], parking_id: str) -> None:
1768        self.evse_position = evse_position
1769        self.parking_id = parking_id
1770
1771    @staticmethod
1772    def from_dict(obj: Any) -> 'EvseParking':
1773        assert isinstance(obj, dict)
1774        evse_position = from_union([from_none, EvsePosition], obj.get("evse_position"))
1775        parking_id = from_str(obj.get("parking_id"))
1776        return EvseParking(evse_position, parking_id)
1777
1778    def to_dict(self) -> dict:
1779        result: dict = {}
1780        if self.evse_position is not None:
1781            result["evse_position"] = from_union([from_none, lambda x: to_enum(EvsePosition, x)], self.evse_position)
1782        result["parking_id"] = from_str(self.parking_id)
1783        return result
1784
1785
1786class ParkingRestriction(Enum):
1787    CUSTOMERS = "CUSTOMERS"
1788    DISABLED = "DISABLED"
1789    EMPLOYEES = "EMPLOYEES"
1790    EV_ONLY = "EV_ONLY"
1791    MOTORCYCLES = "MOTORCYCLES"
1792    PLUGGED = "PLUGGED"
1793    TAXIS = "TAXIS"
1794    TENANTS = "TENANTS"
1795
1796
1797class Status(Enum):
1798    AVAILABLE = "AVAILABLE"
1799    BLOCKED = "BLOCKED"
1800    CHARGING = "CHARGING"
1801    INOPERATIVE = "INOPERATIVE"
1802    OUTOFORDER = "OUTOFORDER"
1803    PLANNED = "PLANNED"
1804    REMOVED = "REMOVED"
1805    RESERVED = "RESERVED"
1806    UNKNOWN = "UNKNOWN"
1807
1808
1809class StatusSchedule:
1810    period_begin: str
1811    period_end: Optional[str]
1812    status: Status
1813
1814    def __init__(self, period_begin: str, period_end: Optional[str], status: Status) -> None:
1815        self.period_begin = period_begin
1816        self.period_end = period_end
1817        self.status = status
1818
1819    @staticmethod
1820    def from_dict(obj: Any) -> 'StatusSchedule':
1821        assert isinstance(obj, dict)
1822        period_begin = from_str(obj.get("period_begin"))
1823        period_end = from_union([from_none, from_str], obj.get("period_end"))
1824        status = Status(obj.get("status"))
1825        return StatusSchedule(period_begin, period_end, status)
1826
1827    def to_dict(self) -> dict:
1828        result: dict = {}
1829        result["period_begin"] = from_str(self.period_begin)
1830        if self.period_end is not None:
1831            result["period_end"] = from_union([from_none, from_str], self.period_end)
1832        result["status"] = to_enum(Status, self.status)
1833        return result
1834
1835
1836class Evse:
1837    accepted_service_providers: Optional[List[str]]
1838    capabilities: Optional[List[Capability]]
1839    connectors: List[Connector]
1840    coordinates: Optional[GeoLocation]
1841    directions: Optional[List[DisplayText]]
1842    evse_id: Optional[str]
1843    floor_level: Optional[str]
1844    images: Optional[List[Image]]
1845    last_updated: str
1846    parking: Optional[List[EvseParking]]
1847    parking_restrictions: Optional[List[ParkingRestriction]]
1848    physical_reference: Optional[str]
1849    status: Status
1850    status_schedule: Optional[List[StatusSchedule]]
1851    uid: str
1852
1853    def __init__(self, accepted_service_providers: Optional[List[str]], capabilities: Optional[List[Capability]], connectors: List[Connector], coordinates: Optional[GeoLocation], directions: Optional[List[DisplayText]], evse_id: Optional[str], floor_level: Optional[str], images: Optional[List[Image]], last_updated: str, parking: Optional[List[EvseParking]], parking_restrictions: Optional[List[ParkingRestriction]], physical_reference: Optional[str], status: Status, status_schedule: Optional[List[StatusSchedule]], uid: str) -> None:
1854        self.accepted_service_providers = accepted_service_providers
1855        self.capabilities = capabilities
1856        self.connectors = connectors
1857        self.coordinates = coordinates
1858        self.directions = directions
1859        self.evse_id = evse_id
1860        self.floor_level = floor_level
1861        self.images = images
1862        self.last_updated = last_updated
1863        self.parking = parking
1864        self.parking_restrictions = parking_restrictions
1865        self.physical_reference = physical_reference
1866        self.status = status
1867        self.status_schedule = status_schedule
1868        self.uid = uid
1869
1870    @staticmethod
1871    def from_dict(obj: Any) -> 'Evse':
1872        assert isinstance(obj, dict)
1873        accepted_service_providers = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("accepted_service_providers"))
1874        capabilities = from_union([from_none, lambda x: from_list(Capability, x)], obj.get("capabilities"))
1875        connectors = from_list(Connector.from_dict, obj.get("connectors"))
1876        coordinates = from_union([from_none, GeoLocation.from_dict], obj.get("coordinates"))
1877        directions = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("directions"))
1878        evse_id = from_union([from_none, from_str], obj.get("evse_id"))
1879        floor_level = from_union([from_none, from_str], obj.get("floor_level"))
1880        images = from_union([from_none, lambda x: from_list(Image.from_dict, x)], obj.get("images"))
1881        last_updated = from_str(obj.get("last_updated"))
1882        parking = from_union([from_none, lambda x: from_list(EvseParking.from_dict, x)], obj.get("parking"))
1883        parking_restrictions = from_union([from_none, lambda x: from_list(ParkingRestriction, x)], obj.get("parking_restrictions"))
1884        physical_reference = from_union([from_none, from_str], obj.get("physical_reference"))
1885        status = Status(obj.get("status"))
1886        status_schedule = from_union([from_none, lambda x: from_list(StatusSchedule.from_dict, x)], obj.get("status_schedule"))
1887        uid = from_str(obj.get("uid"))
1888        return Evse(accepted_service_providers, capabilities, connectors, coordinates, directions, evse_id, floor_level, images, last_updated, parking, parking_restrictions, physical_reference, status, status_schedule, uid)
1889
1890    def to_dict(self) -> dict:
1891        result: dict = {}
1892        if self.accepted_service_providers is not None:
1893            result["accepted_service_providers"] = from_union([from_none, lambda x: from_list(from_str, x)], self.accepted_service_providers)
1894        if self.capabilities is not None:
1895            result["capabilities"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(Capability, x), x)], self.capabilities)
1896        result["connectors"] = from_list(lambda x: to_class(Connector, x), self.connectors)
1897        if self.coordinates is not None:
1898            result["coordinates"] = from_union([from_none, lambda x: to_class(GeoLocation, x)], self.coordinates)
1899        if self.directions is not None:
1900            result["directions"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.directions)
1901        if self.evse_id is not None:
1902            result["evse_id"] = from_union([from_none, from_str], self.evse_id)
1903        if self.floor_level is not None:
1904            result["floor_level"] = from_union([from_none, from_str], self.floor_level)
1905        if self.images is not None:
1906            result["images"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Image, x), x)], self.images)
1907        result["last_updated"] = from_str(self.last_updated)
1908        if self.parking is not None:
1909            result["parking"] = from_union([from_none, lambda x: from_list(lambda x: to_class(EvseParking, x), x)], self.parking)
1910        if self.parking_restrictions is not None:
1911            result["parking_restrictions"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(ParkingRestriction, x), x)], self.parking_restrictions)
1912        if self.physical_reference is not None:
1913            result["physical_reference"] = from_union([from_none, from_str], self.physical_reference)
1914        result["status"] = to_enum(Status, self.status)
1915        if self.status_schedule is not None:
1916            result["status_schedule"] = from_union([from_none, lambda x: from_list(lambda x: to_class(StatusSchedule, x), x)], self.status_schedule)
1917        result["uid"] = from_str(self.uid)
1918        return result
1919
1920
1921class ConnectionStatus(Enum):
1922    CONNECTED = "CONNECTED"
1923    OFFLINE = "OFFLINE"
1924    PLANNED = "PLANNED"
1925    SUSPENDED = "SUSPENDED"
1926
1927
1928class HubClientInfo:
1929    country_code: str
1930    last_updated: str
1931    party_id: str
1932    role: Role
1933    status: ConnectionStatus
1934
1935    def __init__(self, country_code: str, last_updated: str, party_id: str, role: Role, status: ConnectionStatus) -> None:
1936        self.country_code = country_code
1937        self.last_updated = last_updated
1938        self.party_id = party_id
1939        self.role = role
1940        self.status = status
1941
1942    @staticmethod
1943    def from_dict(obj: Any) -> 'HubClientInfo':
1944        assert isinstance(obj, dict)
1945        country_code = from_str(obj.get("country_code"))
1946        last_updated = from_str(obj.get("last_updated"))
1947        party_id = from_str(obj.get("party_id"))
1948        role = Role(obj.get("role"))
1949        status = ConnectionStatus(obj.get("status"))
1950        return HubClientInfo(country_code, last_updated, party_id, role, status)
1951
1952    def to_dict(self) -> dict:
1953        result: dict = {}
1954        result["country_code"] = from_str(self.country_code)
1955        result["last_updated"] = from_str(self.last_updated)
1956        result["party_id"] = from_str(self.party_id)
1957        result["role"] = to_enum(Role, self.role)
1958        result["status"] = to_enum(ConnectionStatus, self.status)
1959        return result
1960
1961
1962class Facility(Enum):
1963    AIRPORT = "AIRPORT"
1964    BIKE_SHARING = "BIKE_SHARING"
1965    BUS_STOP = "BUS_STOP"
1966    CAFE = "CAFE"
1967    CARPOOL_PARKING = "CARPOOL_PARKING"
1968    FUEL_STATION = "FUEL_STATION"
1969    HOTEL = "HOTEL"
1970    MALL = "MALL"
1971    METRO_STATION = "METRO_STATION"
1972    MUSEUM = "MUSEUM"
1973    NATURE = "NATURE"
1974    PARKING_LOT = "PARKING_LOT"
1975    RECREATION_AREA = "RECREATION_AREA"
1976    RESTAURANT = "RESTAURANT"
1977    SPORT = "SPORT"
1978    SUPERMARKET = "SUPERMARKET"
1979    TAXI_STAND = "TAXI_STAND"
1980    TRAIN_STATION = "TRAIN_STATION"
1981    TRAM_STOP = "TRAM_STOP"
1982    WIFI = "WIFI"
1983
1984
1985class ExceptionalPeriod:
1986    period_begin: str
1987    period_end: str
1988
1989    def __init__(self, period_begin: str, period_end: str) -> None:
1990        self.period_begin = period_begin
1991        self.period_end = period_end
1992
1993    @staticmethod
1994    def from_dict(obj: Any) -> 'ExceptionalPeriod':
1995        assert isinstance(obj, dict)
1996        period_begin = from_str(obj.get("period_begin"))
1997        period_end = from_str(obj.get("period_end"))
1998        return ExceptionalPeriod(period_begin, period_end)
1999
2000    def to_dict(self) -> dict:
2001        result: dict = {}
2002        result["period_begin"] = from_str(self.period_begin)
2003        result["period_end"] = from_str(self.period_end)
2004        return result
2005
2006
2007class RegularHours:
2008    period_begin: str
2009    period_end: str
2010    weekday: int
2011
2012    def __init__(self, period_begin: str, period_end: str, weekday: int) -> None:
2013        self.period_begin = period_begin
2014        self.period_end = period_end
2015        self.weekday = weekday
2016
2017    @staticmethod
2018    def from_dict(obj: Any) -> 'RegularHours':
2019        assert isinstance(obj, dict)
2020        period_begin = from_str(obj.get("period_begin"))
2021        period_end = from_str(obj.get("period_end"))
2022        weekday = from_int(obj.get("weekday"))
2023        return RegularHours(period_begin, period_end, weekday)
2024
2025    def to_dict(self) -> dict:
2026        result: dict = {}
2027        result["period_begin"] = from_str(self.period_begin)
2028        result["period_end"] = from_str(self.period_end)
2029        result["weekday"] = from_int(self.weekday)
2030        return result
2031
2032
2033class Hours:
2034    exceptional_closings: Optional[List[ExceptionalPeriod]]
2035    exceptional_openings: Optional[List[ExceptionalPeriod]]
2036    regular_hours: Optional[List[RegularHours]]
2037    twentyfourseven: bool
2038
2039    def __init__(self, exceptional_closings: Optional[List[ExceptionalPeriod]], exceptional_openings: Optional[List[ExceptionalPeriod]], regular_hours: Optional[List[RegularHours]], twentyfourseven: bool) -> None:
2040        self.exceptional_closings = exceptional_closings
2041        self.exceptional_openings = exceptional_openings
2042        self.regular_hours = regular_hours
2043        self.twentyfourseven = twentyfourseven
2044
2045    @staticmethod
2046    def from_dict(obj: Any) -> 'Hours':
2047        assert isinstance(obj, dict)
2048        exceptional_closings = from_union([from_none, lambda x: from_list(ExceptionalPeriod.from_dict, x)], obj.get("exceptional_closings"))
2049        exceptional_openings = from_union([from_none, lambda x: from_list(ExceptionalPeriod.from_dict, x)], obj.get("exceptional_openings"))
2050        regular_hours = from_union([from_none, lambda x: from_list(RegularHours.from_dict, x)], obj.get("regular_hours"))
2051        twentyfourseven = from_bool(obj.get("twentyfourseven"))
2052        return Hours(exceptional_closings, exceptional_openings, regular_hours, twentyfourseven)
2053
2054    def to_dict(self) -> dict:
2055        result: dict = {}
2056        if self.exceptional_closings is not None:
2057            result["exceptional_closings"] = from_union([from_none, lambda x: from_list(lambda x: to_class(ExceptionalPeriod, x), x)], self.exceptional_closings)
2058        if self.exceptional_openings is not None:
2059            result["exceptional_openings"] = from_union([from_none, lambda x: from_list(lambda x: to_class(ExceptionalPeriod, x), x)], self.exceptional_openings)
2060        if self.regular_hours is not None:
2061            result["regular_hours"] = from_union([from_none, lambda x: from_list(lambda x: to_class(RegularHours, x), x)], self.regular_hours)
2062        result["twentyfourseven"] = from_bool(self.twentyfourseven)
2063        return result
2064
2065
2066class ParkingDirection(Enum):
2067    ANGLE = "ANGLE"
2068    PARALLEL = "PARALLEL"
2069    PERPENDICULAR = "PERPENDICULAR"
2070
2071
2072class VehicleType(Enum):
2073    BUS = "BUS"
2074    DISABLED = "DISABLED"
2075    MOTORCYCLE = "MOTORCYCLE"
2076    PERSONAL_VEHICLE = "PERSONAL_VEHICLE"
2077    PERSONAL_VEHICLE_WITH_TRAILER = "PERSONAL_VEHICLE_WITH_TRAILER"
2078    RIGID = "RIGID"
2079    SEMI_TRACTOR = "SEMI_TRACTOR"
2080    TRUCK_WITH_TRAILER = "TRUCK_WITH_TRAILER"
2081    VAN = "VAN"
2082
2083
2084class Parking:
2085    apds_reference: Optional[str]
2086    dangerous_goods_allowed: Optional[bool]
2087    direction: Optional[ParkingDirection]
2088    drive_through: Optional[bool]
2089    id: str
2090    images: Optional[List[Image]]
2091    lighting: Optional[bool]
2092    max_vehicle_height: Optional[float]
2093    max_vehicle_length: Optional[float]
2094    max_vehicle_weight: Optional[float]
2095    max_vehicle_width: Optional[float]
2096    parking_space_length: Optional[float]
2097    parking_space_width: Optional[float]
2098    physical_reference: Optional[str]
2099    refrigeration_outlet: Optional[bool]
2100    reservation_required: bool
2101    restricted_to_type: bool
2102    roofed: Optional[bool]
2103    standards: Optional[List[str]]
2104    time_limit: Optional[float]
2105    vehicle_types: List[VehicleType]
2106
2107    def __init__(self, apds_reference: Optional[str], dangerous_goods_allowed: Optional[bool], direction: Optional[ParkingDirection], drive_through: Optional[bool], id: str, images: Optional[List[Image]], lighting: Optional[bool], max_vehicle_height: Optional[float], max_vehicle_length: Optional[float], max_vehicle_weight: Optional[float], max_vehicle_width: Optional[float], parking_space_length: Optional[float], parking_space_width: Optional[float], physical_reference: Optional[str], refrigeration_outlet: Optional[bool], reservation_required: bool, restricted_to_type: bool, roofed: Optional[bool], standards: Optional[List[str]], time_limit: Optional[float], vehicle_types: List[VehicleType]) -> None:
2108        self.apds_reference = apds_reference
2109        self.dangerous_goods_allowed = dangerous_goods_allowed
2110        self.direction = direction
2111        self.drive_through = drive_through
2112        self.id = id
2113        self.images = images
2114        self.lighting = lighting
2115        self.max_vehicle_height = max_vehicle_height
2116        self.max_vehicle_length = max_vehicle_length
2117        self.max_vehicle_weight = max_vehicle_weight
2118        self.max_vehicle_width = max_vehicle_width
2119        self.parking_space_length = parking_space_length
2120        self.parking_space_width = parking_space_width
2121        self.physical_reference = physical_reference
2122        self.refrigeration_outlet = refrigeration_outlet
2123        self.reservation_required = reservation_required
2124        self.restricted_to_type = restricted_to_type
2125        self.roofed = roofed
2126        self.standards = standards
2127        self.time_limit = time_limit
2128        self.vehicle_types = vehicle_types
2129
2130    @staticmethod
2131    def from_dict(obj: Any) -> 'Parking':
2132        assert isinstance(obj, dict)
2133        apds_reference = from_union([from_none, from_str], obj.get("apds_reference"))
2134        dangerous_goods_allowed = from_union([from_none, from_bool], obj.get("dangerous_goods_allowed"))
2135        direction = from_union([from_none, ParkingDirection], obj.get("direction"))
2136        drive_through = from_union([from_none, from_bool], obj.get("drive_through"))
2137        id = from_str(obj.get("id"))
2138        images = from_union([from_none, lambda x: from_list(Image.from_dict, x)], obj.get("images"))
2139        lighting = from_union([from_none, from_bool], obj.get("lighting"))
2140        max_vehicle_height = from_union([from_none, from_float], obj.get("max_vehicle_height"))
2141        max_vehicle_length = from_union([from_none, from_float], obj.get("max_vehicle_length"))
2142        max_vehicle_weight = from_union([from_none, from_float], obj.get("max_vehicle_weight"))
2143        max_vehicle_width = from_union([from_none, from_float], obj.get("max_vehicle_width"))
2144        parking_space_length = from_union([from_none, from_float], obj.get("parking_space_length"))
2145        parking_space_width = from_union([from_none, from_float], obj.get("parking_space_width"))
2146        physical_reference = from_union([from_none, from_str], obj.get("physical_reference"))
2147        refrigeration_outlet = from_union([from_none, from_bool], obj.get("refrigeration_outlet"))
2148        reservation_required = from_bool(obj.get("reservation_required"))
2149        restricted_to_type = from_bool(obj.get("restricted_to_type"))
2150        roofed = from_union([from_none, from_bool], obj.get("roofed"))
2151        standards = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("standards"))
2152        time_limit = from_union([from_none, from_float], obj.get("time_limit"))
2153        vehicle_types = from_list(VehicleType, obj.get("vehicle_types"))
2154        return Parking(apds_reference, dangerous_goods_allowed, direction, drive_through, id, images, lighting, max_vehicle_height, max_vehicle_length, max_vehicle_weight, max_vehicle_width, parking_space_length, parking_space_width, physical_reference, refrigeration_outlet, reservation_required, restricted_to_type, roofed, standards, time_limit, vehicle_types)
2155
2156    def to_dict(self) -> dict:
2157        result: dict = {}
2158        if self.apds_reference is not None:
2159            result["apds_reference"] = from_union([from_none, from_str], self.apds_reference)
2160        if self.dangerous_goods_allowed is not None:
2161            result["dangerous_goods_allowed"] = from_union([from_none, from_bool], self.dangerous_goods_allowed)
2162        if self.direction is not None:
2163            result["direction"] = from_union([from_none, lambda x: to_enum(ParkingDirection, x)], self.direction)
2164        if self.drive_through is not None:
2165            result["drive_through"] = from_union([from_none, from_bool], self.drive_through)
2166        result["id"] = from_str(self.id)
2167        if self.images is not None:
2168            result["images"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Image, x), x)], self.images)
2169        if self.lighting is not None:
2170            result["lighting"] = from_union([from_none, from_bool], self.lighting)
2171        if self.max_vehicle_height is not None:
2172            result["max_vehicle_height"] = from_union([from_none, to_float], self.max_vehicle_height)
2173        if self.max_vehicle_length is not None:
2174            result["max_vehicle_length"] = from_union([from_none, to_float], self.max_vehicle_length)
2175        if self.max_vehicle_weight is not None:
2176            result["max_vehicle_weight"] = from_union([from_none, to_float], self.max_vehicle_weight)
2177        if self.max_vehicle_width is not None:
2178            result["max_vehicle_width"] = from_union([from_none, to_float], self.max_vehicle_width)
2179        if self.parking_space_length is not None:
2180            result["parking_space_length"] = from_union([from_none, to_float], self.parking_space_length)
2181        if self.parking_space_width is not None:
2182            result["parking_space_width"] = from_union([from_none, to_float], self.parking_space_width)
2183        if self.physical_reference is not None:
2184            result["physical_reference"] = from_union([from_none, from_str], self.physical_reference)
2185        if self.refrigeration_outlet is not None:
2186            result["refrigeration_outlet"] = from_union([from_none, from_bool], self.refrigeration_outlet)
2187        result["reservation_required"] = from_bool(self.reservation_required)
2188        result["restricted_to_type"] = from_bool(self.restricted_to_type)
2189        if self.roofed is not None:
2190            result["roofed"] = from_union([from_none, from_bool], self.roofed)
2191        if self.standards is not None:
2192            result["standards"] = from_union([from_none, lambda x: from_list(from_str, x)], self.standards)
2193        if self.time_limit is not None:
2194            result["time_limit"] = from_union([from_none, to_float], self.time_limit)
2195        result["vehicle_types"] = from_list(lambda x: to_enum(VehicleType, x), self.vehicle_types)
2196        return result
2197
2198
2199class ParkingType(Enum):
2200    ALONG_MOTORWAY = "ALONG_MOTORWAY"
2201    ON_DRIVEWAY = "ON_DRIVEWAY"
2202    ON_STREET = "ON_STREET"
2203    PARKING_GARAGE = "PARKING_GARAGE"
2204    PARKING_LOT = "PARKING_LOT"
2205    UNDERGROUND_GARAGE = "UNDERGROUND_GARAGE"
2206
2207
2208class PublishTokenType:
2209    group_id: Optional[str]
2210    issuer: Optional[str]
2211    type: Optional[TokenType]
2212    uid: Optional[str]
2213    visual_number: Optional[str]
2214
2215    def __init__(self, group_id: Optional[str], issuer: Optional[str], type: Optional[TokenType], uid: Optional[str], visual_number: Optional[str]) -> None:
2216        self.group_id = group_id
2217        self.issuer = issuer
2218        self.type = type
2219        self.uid = uid
2220        self.visual_number = visual_number
2221
2222    @staticmethod
2223    def from_dict(obj: Any) -> 'PublishTokenType':
2224        assert isinstance(obj, dict)
2225        group_id = from_union([from_none, from_str], obj.get("group_id"))
2226        issuer = from_union([from_none, from_str], obj.get("issuer"))
2227        type = from_union([from_none, TokenType], obj.get("type"))
2228        uid = from_union([from_none, from_str], obj.get("uid"))
2229        visual_number = from_union([from_none, from_str], obj.get("visual_number"))
2230        return PublishTokenType(group_id, issuer, type, uid, visual_number)
2231
2232    def to_dict(self) -> dict:
2233        result: dict = {}
2234        if self.group_id is not None:
2235            result["group_id"] = from_union([from_none, from_str], self.group_id)
2236        if self.issuer is not None:
2237            result["issuer"] = from_union([from_none, from_str], self.issuer)
2238        if self.type is not None:
2239            result["type"] = from_union([from_none, lambda x: to_enum(TokenType, x)], self.type)
2240        if self.uid is not None:
2241            result["uid"] = from_union([from_none, from_str], self.uid)
2242        if self.visual_number is not None:
2243            result["visual_number"] = from_union([from_none, from_str], self.visual_number)
2244        return result
2245
2246
2247class AdditionalGeoLocation:
2248    latitude: str
2249    longitude: str
2250    name: Optional[DisplayText]
2251
2252    def __init__(self, latitude: str, longitude: str, name: Optional[DisplayText]) -> None:
2253        self.latitude = latitude
2254        self.longitude = longitude
2255        self.name = name
2256
2257    @staticmethod
2258    def from_dict(obj: Any) -> 'AdditionalGeoLocation':
2259        assert isinstance(obj, dict)
2260        latitude = from_str(obj.get("latitude"))
2261        longitude = from_str(obj.get("longitude"))
2262        name = from_union([from_none, DisplayText.from_dict], obj.get("name"))
2263        return AdditionalGeoLocation(latitude, longitude, name)
2264
2265    def to_dict(self) -> dict:
2266        result: dict = {}
2267        result["latitude"] = from_str(self.latitude)
2268        result["longitude"] = from_str(self.longitude)
2269        if self.name is not None:
2270            result["name"] = from_union([from_none, lambda x: to_class(DisplayText, x)], self.name)
2271        return result
2272
2273
2274class Location:
2275    address: str
2276    charging_when_closed: Optional[bool]
2277    city: str
2278    coordinates: GeoLocation
2279    country: str
2280    country_code: str
2281    directions: Optional[List[DisplayText]]
2282    energy_mix: Optional[EnergyMix]
2283    evses: Optional[List[Evse]]
2284    facilities: Optional[List[Facility]]
2285    help_phone: Optional[str]
2286    id: str
2287    images: Optional[List[Image]]
2288    last_updated: str
2289    name: Optional[str]
2290    opening_times: Optional[Hours]
2291    operator: Optional[BusinessDetails]
2292    owner: Optional[BusinessDetails]
2293    parking_places: Optional[List[Parking]]
2294    parking_type: Optional[ParkingType]
2295    party_id: str
2296    postal_code: Optional[str]
2297    publish: bool
2298    publish_allowed_to: Optional[List[PublishTokenType]]
2299    related_locations: Optional[List[AdditionalGeoLocation]]
2300    state: Optional[str]
2301    suboperator: Optional[BusinessDetails]
2302    time_zone: str
2303
2304    def __init__(self, address: str, charging_when_closed: Optional[bool], city: str, coordinates: GeoLocation, country: str, country_code: str, directions: Optional[List[DisplayText]], energy_mix: Optional[EnergyMix], evses: Optional[List[Evse]], facilities: Optional[List[Facility]], help_phone: Optional[str], id: str, images: Optional[List[Image]], last_updated: str, name: Optional[str], opening_times: Optional[Hours], operator: Optional[BusinessDetails], owner: Optional[BusinessDetails], parking_places: Optional[List[Parking]], parking_type: Optional[ParkingType], party_id: str, postal_code: Optional[str], publish: bool, publish_allowed_to: Optional[List[PublishTokenType]], related_locations: Optional[List[AdditionalGeoLocation]], state: Optional[str], suboperator: Optional[BusinessDetails], time_zone: str) -> None:
2305        self.address = address
2306        self.charging_when_closed = charging_when_closed
2307        self.city = city
2308        self.coordinates = coordinates
2309        self.country = country
2310        self.country_code = country_code
2311        self.directions = directions
2312        self.energy_mix = energy_mix
2313        self.evses = evses
2314        self.facilities = facilities
2315        self.help_phone = help_phone
2316        self.id = id
2317        self.images = images
2318        self.last_updated = last_updated
2319        self.name = name
2320        self.opening_times = opening_times
2321        self.operator = operator
2322        self.owner = owner
2323        self.parking_places = parking_places
2324        self.parking_type = parking_type
2325        self.party_id = party_id
2326        self.postal_code = postal_code
2327        self.publish = publish
2328        self.publish_allowed_to = publish_allowed_to
2329        self.related_locations = related_locations
2330        self.state = state
2331        self.suboperator = suboperator
2332        self.time_zone = time_zone
2333
2334    @staticmethod
2335    def from_dict(obj: Any) -> 'Location':
2336        assert isinstance(obj, dict)
2337        address = from_str(obj.get("address"))
2338        charging_when_closed = from_union([from_none, from_bool], obj.get("charging_when_closed"))
2339        city = from_str(obj.get("city"))
2340        coordinates = GeoLocation.from_dict(obj.get("coordinates"))
2341        country = from_str(obj.get("country"))
2342        country_code = from_str(obj.get("country_code"))
2343        directions = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("directions"))
2344        energy_mix = from_union([from_none, EnergyMix.from_dict], obj.get("energy_mix"))
2345        evses = from_union([from_none, lambda x: from_list(Evse.from_dict, x)], obj.get("evses"))
2346        facilities = from_union([from_none, lambda x: from_list(Facility, x)], obj.get("facilities"))
2347        help_phone = from_union([from_none, from_str], obj.get("help_phone"))
2348        id = from_str(obj.get("id"))
2349        images = from_union([from_none, lambda x: from_list(Image.from_dict, x)], obj.get("images"))
2350        last_updated = from_str(obj.get("last_updated"))
2351        name = from_union([from_none, from_str], obj.get("name"))
2352        opening_times = from_union([from_none, Hours.from_dict], obj.get("opening_times"))
2353        operator = from_union([from_none, BusinessDetails.from_dict], obj.get("operator"))
2354        owner = from_union([from_none, BusinessDetails.from_dict], obj.get("owner"))
2355        parking_places = from_union([from_none, lambda x: from_list(Parking.from_dict, x)], obj.get("parking_places"))
2356        parking_type = from_union([from_none, ParkingType], obj.get("parking_type"))
2357        party_id = from_str(obj.get("party_id"))
2358        postal_code = from_union([from_none, from_str], obj.get("postal_code"))
2359        publish = from_bool(obj.get("publish"))
2360        publish_allowed_to = from_union([from_none, lambda x: from_list(PublishTokenType.from_dict, x)], obj.get("publish_allowed_to"))
2361        related_locations = from_union([from_none, lambda x: from_list(AdditionalGeoLocation.from_dict, x)], obj.get("related_locations"))
2362        state = from_union([from_none, from_str], obj.get("state"))
2363        suboperator = from_union([from_none, BusinessDetails.from_dict], obj.get("suboperator"))
2364        time_zone = from_str(obj.get("time_zone"))
2365        return Location(address, charging_when_closed, city, coordinates, country, country_code, directions, energy_mix, evses, facilities, help_phone, id, images, last_updated, name, opening_times, operator, owner, parking_places, parking_type, party_id, postal_code, publish, publish_allowed_to, related_locations, state, suboperator, time_zone)
2366
2367    def to_dict(self) -> dict:
2368        result: dict = {}
2369        result["address"] = from_str(self.address)
2370        if self.charging_when_closed is not None:
2371            result["charging_when_closed"] = from_union([from_none, from_bool], self.charging_when_closed)
2372        result["city"] = from_str(self.city)
2373        result["coordinates"] = to_class(GeoLocation, self.coordinates)
2374        result["country"] = from_str(self.country)
2375        result["country_code"] = from_str(self.country_code)
2376        if self.directions is not None:
2377            result["directions"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.directions)
2378        if self.energy_mix is not None:
2379            result["energy_mix"] = from_union([from_none, lambda x: to_class(EnergyMix, x)], self.energy_mix)
2380        if self.evses is not None:
2381            result["evses"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Evse, x), x)], self.evses)
2382        if self.facilities is not None:
2383            result["facilities"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(Facility, x), x)], self.facilities)
2384        if self.help_phone is not None:
2385            result["help_phone"] = from_union([from_none, from_str], self.help_phone)
2386        result["id"] = from_str(self.id)
2387        if self.images is not None:
2388            result["images"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Image, x), x)], self.images)
2389        result["last_updated"] = from_str(self.last_updated)
2390        if self.name is not None:
2391            result["name"] = from_union([from_none, from_str], self.name)
2392        if self.opening_times is not None:
2393            result["opening_times"] = from_union([from_none, lambda x: to_class(Hours, x)], self.opening_times)
2394        if self.operator is not None:
2395            result["operator"] = from_union([from_none, lambda x: to_class(BusinessDetails, x)], self.operator)
2396        if self.owner is not None:
2397            result["owner"] = from_union([from_none, lambda x: to_class(BusinessDetails, x)], self.owner)
2398        if self.parking_places is not None:
2399            result["parking_places"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Parking, x), x)], self.parking_places)
2400        if self.parking_type is not None:
2401            result["parking_type"] = from_union([from_none, lambda x: to_enum(ParkingType, x)], self.parking_type)
2402        result["party_id"] = from_str(self.party_id)
2403        if self.postal_code is not None:
2404            result["postal_code"] = from_union([from_none, from_str], self.postal_code)
2405        result["publish"] = from_bool(self.publish)
2406        if self.publish_allowed_to is not None:
2407            result["publish_allowed_to"] = from_union([from_none, lambda x: from_list(lambda x: to_class(PublishTokenType, x), x)], self.publish_allowed_to)
2408        if self.related_locations is not None:
2409            result["related_locations"] = from_union([from_none, lambda x: from_list(lambda x: to_class(AdditionalGeoLocation, x), x)], self.related_locations)
2410        if self.state is not None:
2411            result["state"] = from_union([from_none, from_str], self.state)
2412        if self.suboperator is not None:
2413            result["suboperator"] = from_union([from_none, lambda x: to_class(BusinessDetails, x)], self.suboperator)
2414        result["time_zone"] = from_str(self.time_zone)
2415        return result
2416
2417
2418class ReserveNow:
2419    authorization_reference: Optional[str]
2420    evse_uid: Optional[str]
2421    expiry_date: str
2422    location_id: str
2423    reservation_id: str
2424    response_url: str
2425    token: Token
2426
2427    def __init__(self, authorization_reference: Optional[str], evse_uid: Optional[str], expiry_date: str, location_id: str, reservation_id: str, response_url: str, token: Token) -> None:
2428        self.authorization_reference = authorization_reference
2429        self.evse_uid = evse_uid
2430        self.expiry_date = expiry_date
2431        self.location_id = location_id
2432        self.reservation_id = reservation_id
2433        self.response_url = response_url
2434        self.token = token
2435
2436    @staticmethod
2437    def from_dict(obj: Any) -> 'ReserveNow':
2438        assert isinstance(obj, dict)
2439        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
2440        evse_uid = from_union([from_none, from_str], obj.get("evse_uid"))
2441        expiry_date = from_str(obj.get("expiry_date"))
2442        location_id = from_str(obj.get("location_id"))
2443        reservation_id = from_str(obj.get("reservation_id"))
2444        response_url = from_str(obj.get("response_url"))
2445        token = Token.from_dict(obj.get("token"))
2446        return ReserveNow(authorization_reference, evse_uid, expiry_date, location_id, reservation_id, response_url, token)
2447
2448    def to_dict(self) -> dict:
2449        result: dict = {}
2450        if self.authorization_reference is not None:
2451            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
2452        if self.evse_uid is not None:
2453            result["evse_uid"] = from_union([from_none, from_str], self.evse_uid)
2454        result["expiry_date"] = from_str(self.expiry_date)
2455        result["location_id"] = from_str(self.location_id)
2456        result["reservation_id"] = from_str(self.reservation_id)
2457        result["response_url"] = from_str(self.response_url)
2458        result["token"] = to_class(Token, self.token)
2459        return result
2460
2461
2462class SessionStatus(Enum):
2463    ACTIVE = "ACTIVE"
2464    COMPLETED = "COMPLETED"
2465    INVALID = "INVALID"
2466    PENDING = "PENDING"
2467    RESERVATION = "RESERVATION"
2468
2469
2470class Session:
2471    auth_method: AuthMethod
2472    authorization_reference: Optional[str]
2473    cdr_token: CdrToken
2474    charging_periods: Optional[List[ChargingPeriod]]
2475    connector_id: str
2476    country_code: str
2477    currency: str
2478    end_date_time: Optional[str]
2479    evse_uid: str
2480    id: str
2481    kwh: float
2482    last_updated: str
2483    location_id: str
2484    meter_id: Optional[str]
2485    party_id: str
2486    start_date_time: str
2487    status: SessionStatus
2488    total_cost: Optional[Price]
2489
2490    def __init__(self, auth_method: AuthMethod, authorization_reference: Optional[str], cdr_token: CdrToken, charging_periods: Optional[List[ChargingPeriod]], connector_id: str, country_code: str, currency: str, end_date_time: Optional[str], evse_uid: str, id: str, kwh: float, last_updated: str, location_id: str, meter_id: Optional[str], party_id: str, start_date_time: str, status: SessionStatus, total_cost: Optional[Price]) -> None:
2491        self.auth_method = auth_method
2492        self.authorization_reference = authorization_reference
2493        self.cdr_token = cdr_token
2494        self.charging_periods = charging_periods
2495        self.connector_id = connector_id
2496        self.country_code = country_code
2497        self.currency = currency
2498        self.end_date_time = end_date_time
2499        self.evse_uid = evse_uid
2500        self.id = id
2501        self.kwh = kwh
2502        self.last_updated = last_updated
2503        self.location_id = location_id
2504        self.meter_id = meter_id
2505        self.party_id = party_id
2506        self.start_date_time = start_date_time
2507        self.status = status
2508        self.total_cost = total_cost
2509
2510    @staticmethod
2511    def from_dict(obj: Any) -> 'Session':
2512        assert isinstance(obj, dict)
2513        auth_method = AuthMethod(obj.get("auth_method"))
2514        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
2515        cdr_token = CdrToken.from_dict(obj.get("cdr_token"))
2516        charging_periods = from_union([from_none, lambda x: from_list(ChargingPeriod.from_dict, x)], obj.get("charging_periods"))
2517        connector_id = from_str(obj.get("connector_id"))
2518        country_code = from_str(obj.get("country_code"))
2519        currency = from_str(obj.get("currency"))
2520        end_date_time = from_union([from_none, from_str], obj.get("end_date_time"))
2521        evse_uid = from_str(obj.get("evse_uid"))
2522        id = from_str(obj.get("id"))
2523        kwh = from_float(obj.get("kwh"))
2524        last_updated = from_str(obj.get("last_updated"))
2525        location_id = from_str(obj.get("location_id"))
2526        meter_id = from_union([from_none, from_str], obj.get("meter_id"))
2527        party_id = from_str(obj.get("party_id"))
2528        start_date_time = from_str(obj.get("start_date_time"))
2529        status = SessionStatus(obj.get("status"))
2530        total_cost = from_union([from_none, Price.from_dict], obj.get("total_cost"))
2531        return Session(auth_method, authorization_reference, cdr_token, charging_periods, connector_id, country_code, currency, end_date_time, evse_uid, id, kwh, last_updated, location_id, meter_id, party_id, start_date_time, status, total_cost)
2532
2533    def to_dict(self) -> dict:
2534        result: dict = {}
2535        result["auth_method"] = to_enum(AuthMethod, self.auth_method)
2536        if self.authorization_reference is not None:
2537            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
2538        result["cdr_token"] = to_class(CdrToken, self.cdr_token)
2539        if self.charging_periods is not None:
2540            result["charging_periods"] = from_union([from_none, lambda x: from_list(lambda x: to_class(ChargingPeriod, x), x)], self.charging_periods)
2541        result["connector_id"] = from_str(self.connector_id)
2542        result["country_code"] = from_str(self.country_code)
2543        result["currency"] = from_str(self.currency)
2544        if self.end_date_time is not None:
2545            result["end_date_time"] = from_union([from_none, from_str], self.end_date_time)
2546        result["evse_uid"] = from_str(self.evse_uid)
2547        result["id"] = from_str(self.id)
2548        result["kwh"] = to_float(self.kwh)
2549        result["last_updated"] = from_str(self.last_updated)
2550        result["location_id"] = from_str(self.location_id)
2551        if self.meter_id is not None:
2552            result["meter_id"] = from_union([from_none, from_str], self.meter_id)
2553        result["party_id"] = from_str(self.party_id)
2554        result["start_date_time"] = from_str(self.start_date_time)
2555        result["status"] = to_enum(SessionStatus, self.status)
2556        if self.total_cost is not None:
2557            result["total_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_cost)
2558        return result
2559
2560
2561class SetChargingProfile:
2562    charging_profile: ChargingProfile
2563    response_url: str
2564
2565    def __init__(self, charging_profile: ChargingProfile, response_url: str) -> None:
2566        self.charging_profile = charging_profile
2567        self.response_url = response_url
2568
2569    @staticmethod
2570    def from_dict(obj: Any) -> 'SetChargingProfile':
2571        assert isinstance(obj, dict)
2572        charging_profile = ChargingProfile.from_dict(obj.get("charging_profile"))
2573        response_url = from_str(obj.get("response_url"))
2574        return SetChargingProfile(charging_profile, response_url)
2575
2576    def to_dict(self) -> dict:
2577        result: dict = {}
2578        result["charging_profile"] = to_class(ChargingProfile, self.charging_profile)
2579        result["response_url"] = from_str(self.response_url)
2580        return result
2581
2582
2583class StartSession:
2584    authorization_reference: Optional[str]
2585    connector_id: Optional[str]
2586    evse_uid: Optional[str]
2587    location_id: str
2588    response_url: str
2589    token: Token
2590
2591    def __init__(self, authorization_reference: Optional[str], connector_id: Optional[str], evse_uid: Optional[str], location_id: str, response_url: str, token: Token) -> None:
2592        self.authorization_reference = authorization_reference
2593        self.connector_id = connector_id
2594        self.evse_uid = evse_uid
2595        self.location_id = location_id
2596        self.response_url = response_url
2597        self.token = token
2598
2599    @staticmethod
2600    def from_dict(obj: Any) -> 'StartSession':
2601        assert isinstance(obj, dict)
2602        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
2603        connector_id = from_union([from_none, from_str], obj.get("connector_id"))
2604        evse_uid = from_union([from_none, from_str], obj.get("evse_uid"))
2605        location_id = from_str(obj.get("location_id"))
2606        response_url = from_str(obj.get("response_url"))
2607        token = Token.from_dict(obj.get("token"))
2608        return StartSession(authorization_reference, connector_id, evse_uid, location_id, response_url, token)
2609
2610    def to_dict(self) -> dict:
2611        result: dict = {}
2612        if self.authorization_reference is not None:
2613            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
2614        if self.connector_id is not None:
2615            result["connector_id"] = from_union([from_none, from_str], self.connector_id)
2616        if self.evse_uid is not None:
2617            result["evse_uid"] = from_union([from_none, from_str], self.evse_uid)
2618        result["location_id"] = from_str(self.location_id)
2619        result["response_url"] = from_str(self.response_url)
2620        result["token"] = to_class(Token, self.token)
2621        return result
2622
2623
2624class StopSession:
2625    response_url: str
2626    session_id: str
2627
2628    def __init__(self, response_url: str, session_id: str) -> None:
2629        self.response_url = response_url
2630        self.session_id = session_id
2631
2632    @staticmethod
2633    def from_dict(obj: Any) -> 'StopSession':
2634        assert isinstance(obj, dict)
2635        response_url = from_str(obj.get("response_url"))
2636        session_id = from_str(obj.get("session_id"))
2637        return StopSession(response_url, session_id)
2638
2639    def to_dict(self) -> dict:
2640        result: dict = {}
2641        result["response_url"] = from_str(self.response_url)
2642        result["session_id"] = from_str(self.session_id)
2643        return result
2644
2645
2646class UnlockConnector:
2647    connector_id: str
2648    evse_uid: str
2649    location_id: str
2650    response_url: str
2651
2652    def __init__(self, connector_id: str, evse_uid: str, location_id: str, response_url: str) -> None:
2653        self.connector_id = connector_id
2654        self.evse_uid = evse_uid
2655        self.location_id = location_id
2656        self.response_url = response_url
2657
2658    @staticmethod
2659    def from_dict(obj: Any) -> 'UnlockConnector':
2660        assert isinstance(obj, dict)
2661        connector_id = from_str(obj.get("connector_id"))
2662        evse_uid = from_str(obj.get("evse_uid"))
2663        location_id = from_str(obj.get("location_id"))
2664        response_url = from_str(obj.get("response_url"))
2665        return UnlockConnector(connector_id, evse_uid, location_id, response_url)
2666
2667    def to_dict(self) -> dict:
2668        result: dict = {}
2669        result["connector_id"] = from_str(self.connector_id)
2670        result["evse_uid"] = from_str(self.evse_uid)
2671        result["location_id"] = from_str(self.location_id)
2672        result["response_url"] = from_str(self.response_url)
2673        return result
2674
2675
2676class VersionNumber(Enum):
2677    THE_20 = "2.0"
2678    THE_21 = "2.1"
2679    THE_211 = "2.1.1"
2680    THE_22 = "2.2"
2681    THE_221 = "2.2.1"
2682    THE_230 = "2.3.0"
2683
2684
2685class Version:
2686    url: str
2687    version: VersionNumber
2688
2689    def __init__(self, url: str, version: VersionNumber) -> None:
2690        self.url = url
2691        self.version = version
2692
2693    @staticmethod
2694    def from_dict(obj: Any) -> 'Version':
2695        assert isinstance(obj, dict)
2696        url = from_str(obj.get("url"))
2697        version = VersionNumber(obj.get("version"))
2698        return Version(url, version)
2699
2700    def to_dict(self) -> dict:
2701        result: dict = {}
2702        result["url"] = from_str(self.url)
2703        result["version"] = to_enum(VersionNumber, self.version)
2704        return result
2705
2706
2707class VersionDetails:
2708    endpoints: List[Endpoint]
2709    version: VersionNumber
2710
2711    def __init__(self, endpoints: List[Endpoint], version: VersionNumber) -> None:
2712        self.endpoints = endpoints
2713        self.version = version
2714
2715    @staticmethod
2716    def from_dict(obj: Any) -> 'VersionDetails':
2717        assert isinstance(obj, dict)
2718        endpoints = from_list(Endpoint.from_dict, obj.get("endpoints"))
2719        version = VersionNumber(obj.get("version"))
2720        return VersionDetails(endpoints, version)
2721
2722    def to_dict(self) -> dict:
2723        result: dict = {}
2724        result["endpoints"] = from_list(lambda x: to_class(Endpoint, x), self.endpoints)
2725        result["version"] = to_enum(VersionNumber, self.version)
2726        return result
2727
2728
2729class V230:
2730    active_charging_profile: Optional[ActiveChargingProfile]
2731    active_charging_profile_result: Optional[ActiveChargingProfileResult]
2732    authorization_info: Optional[AuthorizationInfo]
2733    cancel_reservation: Optional[CancelReservation]
2734    cdr: Optional[Cdr]
2735    charging_preferences: Optional[ChargingPreferences]
2736    charging_profile: Optional[ChargingProfile]
2737    charging_profile_response: Optional[ChargingProfileResponse]
2738    charging_profile_result: Optional[ChargingProfileResult]
2739    clear_profile_result: Optional[ClearProfileResult]
2740    command_response: Optional[CommandResponse]
2741    command_result: Optional[CommandResult]
2742    connector: Optional[Connector]
2743    credentials: Optional[Credentials]
2744    endpoint: Optional[Endpoint]
2745    evse: Optional[Evse]
2746    hub_client_info: Optional[HubClientInfo]
2747    location: Optional[Location]
2748    location_references: Optional[LocationReferences]
2749    reserve_now: Optional[ReserveNow]
2750    session: Optional[Session]
2751    set_charging_profile: Optional[SetChargingProfile]
2752    start_session: Optional[StartSession]
2753    stop_session: Optional[StopSession]
2754    tariff: Optional[Tariff]
2755    token: Optional[Token]
2756    unlock_connector: Optional[UnlockConnector]
2757    version: Optional[Version]
2758    version_details: Optional[VersionDetails]
2759
2760    def __init__(self, active_charging_profile: Optional[ActiveChargingProfile], active_charging_profile_result: Optional[ActiveChargingProfileResult], authorization_info: Optional[AuthorizationInfo], cancel_reservation: Optional[CancelReservation], cdr: Optional[Cdr], charging_preferences: Optional[ChargingPreferences], charging_profile: Optional[ChargingProfile], charging_profile_response: Optional[ChargingProfileResponse], charging_profile_result: Optional[ChargingProfileResult], clear_profile_result: Optional[ClearProfileResult], command_response: Optional[CommandResponse], command_result: Optional[CommandResult], connector: Optional[Connector], credentials: Optional[Credentials], endpoint: Optional[Endpoint], evse: Optional[Evse], hub_client_info: Optional[HubClientInfo], location: Optional[Location], location_references: Optional[LocationReferences], reserve_now: Optional[ReserveNow], session: Optional[Session], set_charging_profile: Optional[SetChargingProfile], start_session: Optional[StartSession], stop_session: Optional[StopSession], tariff: Optional[Tariff], token: Optional[Token], unlock_connector: Optional[UnlockConnector], version: Optional[Version], version_details: Optional[VersionDetails]) -> None:
2761        self.active_charging_profile = active_charging_profile
2762        self.active_charging_profile_result = active_charging_profile_result
2763        self.authorization_info = authorization_info
2764        self.cancel_reservation = cancel_reservation
2765        self.cdr = cdr
2766        self.charging_preferences = charging_preferences
2767        self.charging_profile = charging_profile
2768        self.charging_profile_response = charging_profile_response
2769        self.charging_profile_result = charging_profile_result
2770        self.clear_profile_result = clear_profile_result
2771        self.command_response = command_response
2772        self.command_result = command_result
2773        self.connector = connector
2774        self.credentials = credentials
2775        self.endpoint = endpoint
2776        self.evse = evse
2777        self.hub_client_info = hub_client_info
2778        self.location = location
2779        self.location_references = location_references
2780        self.reserve_now = reserve_now
2781        self.session = session
2782        self.set_charging_profile = set_charging_profile
2783        self.start_session = start_session
2784        self.stop_session = stop_session
2785        self.tariff = tariff
2786        self.token = token
2787        self.unlock_connector = unlock_connector
2788        self.version = version
2789        self.version_details = version_details
2790
2791    @staticmethod
2792    def from_dict(obj: Any) -> 'V230':
2793        assert isinstance(obj, dict)
2794        active_charging_profile = from_union([ActiveChargingProfile.from_dict, from_none], obj.get("active_charging_profile"))
2795        active_charging_profile_result = from_union([ActiveChargingProfileResult.from_dict, from_none], obj.get("active_charging_profile_result"))
2796        authorization_info = from_union([AuthorizationInfo.from_dict, from_none], obj.get("authorization_info"))
2797        cancel_reservation = from_union([CancelReservation.from_dict, from_none], obj.get("cancel_reservation"))
2798        cdr = from_union([Cdr.from_dict, from_none], obj.get("cdr"))
2799        charging_preferences = from_union([ChargingPreferences.from_dict, from_none], obj.get("charging_preferences"))
2800        charging_profile = from_union([ChargingProfile.from_dict, from_none], obj.get("charging_profile"))
2801        charging_profile_response = from_union([ChargingProfileResponse.from_dict, from_none], obj.get("charging_profile_response"))
2802        charging_profile_result = from_union([ChargingProfileResult.from_dict, from_none], obj.get("charging_profile_result"))
2803        clear_profile_result = from_union([ClearProfileResult.from_dict, from_none], obj.get("clear_profile_result"))
2804        command_response = from_union([CommandResponse.from_dict, from_none], obj.get("command_response"))
2805        command_result = from_union([CommandResult.from_dict, from_none], obj.get("command_result"))
2806        connector = from_union([Connector.from_dict, from_none], obj.get("connector"))
2807        credentials = from_union([Credentials.from_dict, from_none], obj.get("credentials"))
2808        endpoint = from_union([Endpoint.from_dict, from_none], obj.get("endpoint"))
2809        evse = from_union([Evse.from_dict, from_none], obj.get("evse"))
2810        hub_client_info = from_union([HubClientInfo.from_dict, from_none], obj.get("hub_client_info"))
2811        location = from_union([Location.from_dict, from_none], obj.get("location"))
2812        location_references = from_union([from_none, LocationReferences.from_dict], obj.get("location_references"))
2813        reserve_now = from_union([ReserveNow.from_dict, from_none], obj.get("reserve_now"))
2814        session = from_union([Session.from_dict, from_none], obj.get("session"))
2815        set_charging_profile = from_union([SetChargingProfile.from_dict, from_none], obj.get("set_charging_profile"))
2816        start_session = from_union([StartSession.from_dict, from_none], obj.get("start_session"))
2817        stop_session = from_union([StopSession.from_dict, from_none], obj.get("stop_session"))
2818        tariff = from_union([Tariff.from_dict, from_none], obj.get("tariff"))
2819        token = from_union([Token.from_dict, from_none], obj.get("token"))
2820        unlock_connector = from_union([UnlockConnector.from_dict, from_none], obj.get("unlock_connector"))
2821        version = from_union([Version.from_dict, from_none], obj.get("version"))
2822        version_details = from_union([VersionDetails.from_dict, from_none], obj.get("version_details"))
2823        return V230(active_charging_profile, active_charging_profile_result, authorization_info, cancel_reservation, cdr, charging_preferences, charging_profile, charging_profile_response, charging_profile_result, clear_profile_result, command_response, command_result, connector, credentials, endpoint, evse, hub_client_info, location, location_references, reserve_now, session, set_charging_profile, start_session, stop_session, tariff, token, unlock_connector, version, version_details)
2824
2825    def to_dict(self) -> dict:
2826        result: dict = {}
2827        if self.active_charging_profile is not None:
2828            result["active_charging_profile"] = from_union([lambda x: to_class(ActiveChargingProfile, x), from_none], self.active_charging_profile)
2829        if self.active_charging_profile_result is not None:
2830            result["active_charging_profile_result"] = from_union([lambda x: to_class(ActiveChargingProfileResult, x), from_none], self.active_charging_profile_result)
2831        if self.authorization_info is not None:
2832            result["authorization_info"] = from_union([lambda x: to_class(AuthorizationInfo, x), from_none], self.authorization_info)
2833        if self.cancel_reservation is not None:
2834            result["cancel_reservation"] = from_union([lambda x: to_class(CancelReservation, x), from_none], self.cancel_reservation)
2835        if self.cdr is not None:
2836            result["cdr"] = from_union([lambda x: to_class(Cdr, x), from_none], self.cdr)
2837        if self.charging_preferences is not None:
2838            result["charging_preferences"] = from_union([lambda x: to_class(ChargingPreferences, x), from_none], self.charging_preferences)
2839        if self.charging_profile is not None:
2840            result["charging_profile"] = from_union([lambda x: to_class(ChargingProfile, x), from_none], self.charging_profile)
2841        if self.charging_profile_response is not None:
2842            result["charging_profile_response"] = from_union([lambda x: to_class(ChargingProfileResponse, x), from_none], self.charging_profile_response)
2843        if self.charging_profile_result is not None:
2844            result["charging_profile_result"] = from_union([lambda x: to_class(ChargingProfileResult, x), from_none], self.charging_profile_result)
2845        if self.clear_profile_result is not None:
2846            result["clear_profile_result"] = from_union([lambda x: to_class(ClearProfileResult, x), from_none], self.clear_profile_result)
2847        if self.command_response is not None:
2848            result["command_response"] = from_union([lambda x: to_class(CommandResponse, x), from_none], self.command_response)
2849        if self.command_result is not None:
2850            result["command_result"] = from_union([lambda x: to_class(CommandResult, x), from_none], self.command_result)
2851        if self.connector is not None:
2852            result["connector"] = from_union([lambda x: to_class(Connector, x), from_none], self.connector)
2853        if self.credentials is not None:
2854            result["credentials"] = from_union([lambda x: to_class(Credentials, x), from_none], self.credentials)
2855        if self.endpoint is not None:
2856            result["endpoint"] = from_union([lambda x: to_class(Endpoint, x), from_none], self.endpoint)
2857        if self.evse is not None:
2858            result["evse"] = from_union([lambda x: to_class(Evse, x), from_none], self.evse)
2859        if self.hub_client_info is not None:
2860            result["hub_client_info"] = from_union([lambda x: to_class(HubClientInfo, x), from_none], self.hub_client_info)
2861        if self.location is not None:
2862            result["location"] = from_union([lambda x: to_class(Location, x), from_none], self.location)
2863        if self.location_references is not None:
2864            result["location_references"] = from_union([from_none, lambda x: to_class(LocationReferences, x)], self.location_references)
2865        if self.reserve_now is not None:
2866            result["reserve_now"] = from_union([lambda x: to_class(ReserveNow, x), from_none], self.reserve_now)
2867        if self.session is not None:
2868            result["session"] = from_union([lambda x: to_class(Session, x), from_none], self.session)
2869        if self.set_charging_profile is not None:
2870            result["set_charging_profile"] = from_union([lambda x: to_class(SetChargingProfile, x), from_none], self.set_charging_profile)
2871        if self.start_session is not None:
2872            result["start_session"] = from_union([lambda x: to_class(StartSession, x), from_none], self.start_session)
2873        if self.stop_session is not None:
2874            result["stop_session"] = from_union([lambda x: to_class(StopSession, x), from_none], self.stop_session)
2875        if self.tariff is not None:
2876            result["tariff"] = from_union([lambda x: to_class(Tariff, x), from_none], self.tariff)
2877        if self.token is not None:
2878            result["token"] = from_union([lambda x: to_class(Token, x), from_none], self.token)
2879        if self.unlock_connector is not None:
2880            result["unlock_connector"] = from_union([lambda x: to_class(UnlockConnector, x), from_none], self.unlock_connector)
2881        if self.version is not None:
2882            result["version"] = from_union([lambda x: to_class(Version, x), from_none], self.version)
2883        if self.version_details is not None:
2884            result["version_details"] = from_union([lambda x: to_class(VersionDetails, x), from_none], self.version_details)
2885        return result
2886
2887
2888def v230_from_dict(s: Any) -> V230:
2889    return V230.from_dict(s)
2890
2891
2892def v230_to_dict(x: V230) -> Any:
2893    return to_class(V230, x)