v230payments

   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    preauthorize_amount: Optional[float]
1039    start_date_time: Optional[str]
1040    tariff_alt_text: Optional[List[DisplayText]]
1041    tariff_alt_url: Optional[str]
1042    tax_included: TaxIncluded
1043    type: Optional[TariffType]
1044
1045    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, preauthorize_amount: Optional[float], start_date_time: Optional[str], tariff_alt_text: Optional[List[DisplayText]], tariff_alt_url: Optional[str], tax_included: TaxIncluded, type: Optional[TariffType]) -> None:
1046        self.country_code = country_code
1047        self.currency = currency
1048        self.elements = elements
1049        self.end_date_time = end_date_time
1050        self.energy_mix = energy_mix
1051        self.id = id
1052        self.last_updated = last_updated
1053        self.max_price = max_price
1054        self.min_price = min_price
1055        self.party_id = party_id
1056        self.preauthorize_amount = preauthorize_amount
1057        self.start_date_time = start_date_time
1058        self.tariff_alt_text = tariff_alt_text
1059        self.tariff_alt_url = tariff_alt_url
1060        self.tax_included = tax_included
1061        self.type = type
1062
1063    @staticmethod
1064    def from_dict(obj: Any) -> 'Tariff':
1065        assert isinstance(obj, dict)
1066        country_code = from_str(obj.get("country_code"))
1067        currency = from_str(obj.get("currency"))
1068        elements = from_list(TariffElement.from_dict, obj.get("elements"))
1069        end_date_time = from_union([from_none, from_str], obj.get("end_date_time"))
1070        energy_mix = from_union([from_none, EnergyMix.from_dict], obj.get("energy_mix"))
1071        id = from_str(obj.get("id"))
1072        last_updated = from_str(obj.get("last_updated"))
1073        max_price = from_union([from_none, PriceLimit.from_dict], obj.get("max_price"))
1074        min_price = from_union([from_none, PriceLimit.from_dict], obj.get("min_price"))
1075        party_id = from_str(obj.get("party_id"))
1076        preauthorize_amount = from_union([from_none, from_float], obj.get("preauthorize_amount"))
1077        start_date_time = from_union([from_none, from_str], obj.get("start_date_time"))
1078        tariff_alt_text = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("tariff_alt_text"))
1079        tariff_alt_url = from_union([from_none, from_str], obj.get("tariff_alt_url"))
1080        tax_included = TaxIncluded(obj.get("tax_included"))
1081        type = from_union([from_none, TariffType], obj.get("type"))
1082        return Tariff(country_code, currency, elements, end_date_time, energy_mix, id, last_updated, max_price, min_price, party_id, preauthorize_amount, start_date_time, tariff_alt_text, tariff_alt_url, tax_included, type)
1083
1084    def to_dict(self) -> dict:
1085        result: dict = {}
1086        result["country_code"] = from_str(self.country_code)
1087        result["currency"] = from_str(self.currency)
1088        result["elements"] = from_list(lambda x: to_class(TariffElement, x), self.elements)
1089        if self.end_date_time is not None:
1090            result["end_date_time"] = from_union([from_none, from_str], self.end_date_time)
1091        if self.energy_mix is not None:
1092            result["energy_mix"] = from_union([from_none, lambda x: to_class(EnergyMix, x)], self.energy_mix)
1093        result["id"] = from_str(self.id)
1094        result["last_updated"] = from_str(self.last_updated)
1095        if self.max_price is not None:
1096            result["max_price"] = from_union([from_none, lambda x: to_class(PriceLimit, x)], self.max_price)
1097        if self.min_price is not None:
1098            result["min_price"] = from_union([from_none, lambda x: to_class(PriceLimit, x)], self.min_price)
1099        result["party_id"] = from_str(self.party_id)
1100        if self.preauthorize_amount is not None:
1101            result["preauthorize_amount"] = from_union([from_none, to_float], self.preauthorize_amount)
1102        if self.start_date_time is not None:
1103            result["start_date_time"] = from_union([from_none, from_str], self.start_date_time)
1104        if self.tariff_alt_text is not None:
1105            result["tariff_alt_text"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.tariff_alt_text)
1106        if self.tariff_alt_url is not None:
1107            result["tariff_alt_url"] = from_union([from_none, from_str], self.tariff_alt_url)
1108        result["tax_included"] = to_enum(TaxIncluded, self.tax_included)
1109        if self.type is not None:
1110            result["type"] = from_union([from_none, lambda x: to_enum(TariffType, x)], self.type)
1111        return result
1112
1113
1114class TaxAmount:
1115    account_number: Optional[str]
1116    amount: float
1117    name: str
1118    percentage: Optional[float]
1119
1120    def __init__(self, account_number: Optional[str], amount: float, name: str, percentage: Optional[float]) -> None:
1121        self.account_number = account_number
1122        self.amount = amount
1123        self.name = name
1124        self.percentage = percentage
1125
1126    @staticmethod
1127    def from_dict(obj: Any) -> 'TaxAmount':
1128        assert isinstance(obj, dict)
1129        account_number = from_union([from_none, from_str], obj.get("account_number"))
1130        amount = from_float(obj.get("amount"))
1131        name = from_str(obj.get("name"))
1132        percentage = from_union([from_none, from_float], obj.get("percentage"))
1133        return TaxAmount(account_number, amount, name, percentage)
1134
1135    def to_dict(self) -> dict:
1136        result: dict = {}
1137        if self.account_number is not None:
1138            result["account_number"] = from_union([from_none, from_str], self.account_number)
1139        result["amount"] = to_float(self.amount)
1140        result["name"] = from_str(self.name)
1141        if self.percentage is not None:
1142            result["percentage"] = from_union([from_none, to_float], self.percentage)
1143        return result
1144
1145
1146class Price:
1147    before_taxes: float
1148    taxes: Optional[List[TaxAmount]]
1149
1150    def __init__(self, before_taxes: float, taxes: Optional[List[TaxAmount]]) -> None:
1151        self.before_taxes = before_taxes
1152        self.taxes = taxes
1153
1154    @staticmethod
1155    def from_dict(obj: Any) -> 'Price':
1156        assert isinstance(obj, dict)
1157        before_taxes = from_float(obj.get("before_taxes"))
1158        taxes = from_union([from_none, lambda x: from_list(TaxAmount.from_dict, x)], obj.get("taxes"))
1159        return Price(before_taxes, taxes)
1160
1161    def to_dict(self) -> dict:
1162        result: dict = {}
1163        result["before_taxes"] = to_float(self.before_taxes)
1164        if self.taxes is not None:
1165            result["taxes"] = from_union([from_none, lambda x: from_list(lambda x: to_class(TaxAmount, x), x)], self.taxes)
1166        return result
1167
1168
1169class Cdr:
1170    auth_method: AuthMethod
1171    authorization_reference: Optional[str]
1172    cdr_location: CdrLocation
1173    cdr_token: CdrToken
1174    charging_periods: List[ChargingPeriod]
1175    country_code: str
1176    credit: Optional[bool]
1177    credit_reference_id: Optional[str]
1178    currency: str
1179    end_date_time: str
1180    home_charging_compensation: Optional[bool]
1181    id: str
1182    invoice_reference_id: Optional[str]
1183    last_updated: str
1184    meter_id: Optional[str]
1185    party_id: str
1186    remark: Optional[str]
1187    session_id: Optional[str]
1188    signed_data: Optional[SignedData]
1189    start_date_time: str
1190    tariffs: Optional[List[Tariff]]
1191    total_cost: Price
1192    total_energy: float
1193    total_energy_cost: Optional[Price]
1194    total_fixed_cost: Optional[Price]
1195    total_parking_cost: Optional[Price]
1196    total_parking_time: Optional[float]
1197    total_reservation_cost: Optional[Price]
1198    total_time: float
1199    total_time_cost: Optional[Price]
1200
1201    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:
1202        self.auth_method = auth_method
1203        self.authorization_reference = authorization_reference
1204        self.cdr_location = cdr_location
1205        self.cdr_token = cdr_token
1206        self.charging_periods = charging_periods
1207        self.country_code = country_code
1208        self.credit = credit
1209        self.credit_reference_id = credit_reference_id
1210        self.currency = currency
1211        self.end_date_time = end_date_time
1212        self.home_charging_compensation = home_charging_compensation
1213        self.id = id
1214        self.invoice_reference_id = invoice_reference_id
1215        self.last_updated = last_updated
1216        self.meter_id = meter_id
1217        self.party_id = party_id
1218        self.remark = remark
1219        self.session_id = session_id
1220        self.signed_data = signed_data
1221        self.start_date_time = start_date_time
1222        self.tariffs = tariffs
1223        self.total_cost = total_cost
1224        self.total_energy = total_energy
1225        self.total_energy_cost = total_energy_cost
1226        self.total_fixed_cost = total_fixed_cost
1227        self.total_parking_cost = total_parking_cost
1228        self.total_parking_time = total_parking_time
1229        self.total_reservation_cost = total_reservation_cost
1230        self.total_time = total_time
1231        self.total_time_cost = total_time_cost
1232
1233    @staticmethod
1234    def from_dict(obj: Any) -> 'Cdr':
1235        assert isinstance(obj, dict)
1236        auth_method = AuthMethod(obj.get("auth_method"))
1237        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
1238        cdr_location = CdrLocation.from_dict(obj.get("cdr_location"))
1239        cdr_token = CdrToken.from_dict(obj.get("cdr_token"))
1240        charging_periods = from_list(ChargingPeriod.from_dict, obj.get("charging_periods"))
1241        country_code = from_str(obj.get("country_code"))
1242        credit = from_union([from_none, from_bool], obj.get("credit"))
1243        credit_reference_id = from_union([from_none, from_str], obj.get("credit_reference_id"))
1244        currency = from_str(obj.get("currency"))
1245        end_date_time = from_str(obj.get("end_date_time"))
1246        home_charging_compensation = from_union([from_none, from_bool], obj.get("home_charging_compensation"))
1247        id = from_str(obj.get("id"))
1248        invoice_reference_id = from_union([from_none, from_str], obj.get("invoice_reference_id"))
1249        last_updated = from_str(obj.get("last_updated"))
1250        meter_id = from_union([from_none, from_str], obj.get("meter_id"))
1251        party_id = from_str(obj.get("party_id"))
1252        remark = from_union([from_none, from_str], obj.get("remark"))
1253        session_id = from_union([from_none, from_str], obj.get("session_id"))
1254        signed_data = from_union([from_none, SignedData.from_dict], obj.get("signed_data"))
1255        start_date_time = from_str(obj.get("start_date_time"))
1256        tariffs = from_union([from_none, lambda x: from_list(Tariff.from_dict, x)], obj.get("tariffs"))
1257        total_cost = Price.from_dict(obj.get("total_cost"))
1258        total_energy = from_float(obj.get("total_energy"))
1259        total_energy_cost = from_union([from_none, Price.from_dict], obj.get("total_energy_cost"))
1260        total_fixed_cost = from_union([from_none, Price.from_dict], obj.get("total_fixed_cost"))
1261        total_parking_cost = from_union([from_none, Price.from_dict], obj.get("total_parking_cost"))
1262        total_parking_time = from_union([from_none, from_float], obj.get("total_parking_time"))
1263        total_reservation_cost = from_union([from_none, Price.from_dict], obj.get("total_reservation_cost"))
1264        total_time = from_float(obj.get("total_time"))
1265        total_time_cost = from_union([from_none, Price.from_dict], obj.get("total_time_cost"))
1266        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)
1267
1268    def to_dict(self) -> dict:
1269        result: dict = {}
1270        result["auth_method"] = to_enum(AuthMethod, self.auth_method)
1271        if self.authorization_reference is not None:
1272            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
1273        result["cdr_location"] = to_class(CdrLocation, self.cdr_location)
1274        result["cdr_token"] = to_class(CdrToken, self.cdr_token)
1275        result["charging_periods"] = from_list(lambda x: to_class(ChargingPeriod, x), self.charging_periods)
1276        result["country_code"] = from_str(self.country_code)
1277        if self.credit is not None:
1278            result["credit"] = from_union([from_none, from_bool], self.credit)
1279        if self.credit_reference_id is not None:
1280            result["credit_reference_id"] = from_union([from_none, from_str], self.credit_reference_id)
1281        result["currency"] = from_str(self.currency)
1282        result["end_date_time"] = from_str(self.end_date_time)
1283        if self.home_charging_compensation is not None:
1284            result["home_charging_compensation"] = from_union([from_none, from_bool], self.home_charging_compensation)
1285        result["id"] = from_str(self.id)
1286        if self.invoice_reference_id is not None:
1287            result["invoice_reference_id"] = from_union([from_none, from_str], self.invoice_reference_id)
1288        result["last_updated"] = from_str(self.last_updated)
1289        if self.meter_id is not None:
1290            result["meter_id"] = from_union([from_none, from_str], self.meter_id)
1291        result["party_id"] = from_str(self.party_id)
1292        if self.remark is not None:
1293            result["remark"] = from_union([from_none, from_str], self.remark)
1294        if self.session_id is not None:
1295            result["session_id"] = from_union([from_none, from_str], self.session_id)
1296        if self.signed_data is not None:
1297            result["signed_data"] = from_union([from_none, lambda x: to_class(SignedData, x)], self.signed_data)
1298        result["start_date_time"] = from_str(self.start_date_time)
1299        if self.tariffs is not None:
1300            result["tariffs"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Tariff, x), x)], self.tariffs)
1301        result["total_cost"] = to_class(Price, self.total_cost)
1302        result["total_energy"] = to_float(self.total_energy)
1303        if self.total_energy_cost is not None:
1304            result["total_energy_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_energy_cost)
1305        if self.total_fixed_cost is not None:
1306            result["total_fixed_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_fixed_cost)
1307        if self.total_parking_cost is not None:
1308            result["total_parking_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_parking_cost)
1309        if self.total_parking_time is not None:
1310            result["total_parking_time"] = from_union([from_none, to_float], self.total_parking_time)
1311        if self.total_reservation_cost is not None:
1312            result["total_reservation_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_reservation_cost)
1313        result["total_time"] = to_float(self.total_time)
1314        if self.total_time_cost is not None:
1315            result["total_time_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_time_cost)
1316        return result
1317
1318
1319class ChargingPreferences:
1320    departure_time: Optional[str]
1321    discharge_allowed: Optional[bool]
1322    energy_need: Optional[float]
1323    profile_type: ProfileType
1324
1325    def __init__(self, departure_time: Optional[str], discharge_allowed: Optional[bool], energy_need: Optional[float], profile_type: ProfileType) -> None:
1326        self.departure_time = departure_time
1327        self.discharge_allowed = discharge_allowed
1328        self.energy_need = energy_need
1329        self.profile_type = profile_type
1330
1331    @staticmethod
1332    def from_dict(obj: Any) -> 'ChargingPreferences':
1333        assert isinstance(obj, dict)
1334        departure_time = from_union([from_none, from_str], obj.get("departure_time"))
1335        discharge_allowed = from_union([from_none, from_bool], obj.get("discharge_allowed"))
1336        energy_need = from_union([from_none, from_float], obj.get("energy_need"))
1337        profile_type = ProfileType(obj.get("profile_type"))
1338        return ChargingPreferences(departure_time, discharge_allowed, energy_need, profile_type)
1339
1340    def to_dict(self) -> dict:
1341        result: dict = {}
1342        if self.departure_time is not None:
1343            result["departure_time"] = from_union([from_none, from_str], self.departure_time)
1344        if self.discharge_allowed is not None:
1345            result["discharge_allowed"] = from_union([from_none, from_bool], self.discharge_allowed)
1346        if self.energy_need is not None:
1347            result["energy_need"] = from_union([from_none, to_float], self.energy_need)
1348        result["profile_type"] = to_enum(ProfileType, self.profile_type)
1349        return result
1350
1351
1352class ChargingProfileResponseType(Enum):
1353    ACCEPTED = "ACCEPTED"
1354    NOT_SUPPORTED = "NOT_SUPPORTED"
1355    REJECTED = "REJECTED"
1356    TOO_OFTEN = "TOO_OFTEN"
1357    UNKNOWN_SESSION = "UNKNOWN_SESSION"
1358
1359
1360class ChargingProfileResponse:
1361    result: ChargingProfileResponseType
1362    timeout: int
1363
1364    def __init__(self, result: ChargingProfileResponseType, timeout: int) -> None:
1365        self.result = result
1366        self.timeout = timeout
1367
1368    @staticmethod
1369    def from_dict(obj: Any) -> 'ChargingProfileResponse':
1370        assert isinstance(obj, dict)
1371        result = ChargingProfileResponseType(obj.get("result"))
1372        timeout = from_int(obj.get("timeout"))
1373        return ChargingProfileResponse(result, timeout)
1374
1375    def to_dict(self) -> dict:
1376        result: dict = {}
1377        result["result"] = to_enum(ChargingProfileResponseType, self.result)
1378        result["timeout"] = from_int(self.timeout)
1379        return result
1380
1381
1382class ChargingProfileResult:
1383    result: ChargingProfileResultType
1384
1385    def __init__(self, result: ChargingProfileResultType) -> None:
1386        self.result = result
1387
1388    @staticmethod
1389    def from_dict(obj: Any) -> 'ChargingProfileResult':
1390        assert isinstance(obj, dict)
1391        result = ChargingProfileResultType(obj.get("result"))
1392        return ChargingProfileResult(result)
1393
1394    def to_dict(self) -> dict:
1395        result: dict = {}
1396        result["result"] = to_enum(ChargingProfileResultType, self.result)
1397        return result
1398
1399
1400class ClearProfileResult:
1401    result: ChargingProfileResultType
1402
1403    def __init__(self, result: ChargingProfileResultType) -> None:
1404        self.result = result
1405
1406    @staticmethod
1407    def from_dict(obj: Any) -> 'ClearProfileResult':
1408        assert isinstance(obj, dict)
1409        result = ChargingProfileResultType(obj.get("result"))
1410        return ClearProfileResult(result)
1411
1412    def to_dict(self) -> dict:
1413        result: dict = {}
1414        result["result"] = to_enum(ChargingProfileResultType, self.result)
1415        return result
1416
1417
1418class CommandResponseType(Enum):
1419    ACCEPTED = "ACCEPTED"
1420    NOT_SUPPORTED = "NOT_SUPPORTED"
1421    REJECTED = "REJECTED"
1422    UNKNOWN_SESSION = "UNKNOWN_SESSION"
1423
1424
1425class CommandResponse:
1426    message: Optional[List[DisplayText]]
1427    result: CommandResponseType
1428    timeout: int
1429
1430    def __init__(self, message: Optional[List[DisplayText]], result: CommandResponseType, timeout: int) -> None:
1431        self.message = message
1432        self.result = result
1433        self.timeout = timeout
1434
1435    @staticmethod
1436    def from_dict(obj: Any) -> 'CommandResponse':
1437        assert isinstance(obj, dict)
1438        message = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("message"))
1439        result = CommandResponseType(obj.get("result"))
1440        timeout = from_int(obj.get("timeout"))
1441        return CommandResponse(message, result, timeout)
1442
1443    def to_dict(self) -> dict:
1444        result: dict = {}
1445        if self.message is not None:
1446            result["message"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.message)
1447        result["result"] = to_enum(CommandResponseType, self.result)
1448        result["timeout"] = from_int(self.timeout)
1449        return result
1450
1451
1452class CommandResultType(Enum):
1453    ACCEPTED = "ACCEPTED"
1454    CANCELED_RESERVATION = "CANCELED_RESERVATION"
1455    EVSE_INOPERATIVE = "EVSE_INOPERATIVE"
1456    EVSE_OCCUPIED = "EVSE_OCCUPIED"
1457    FAILED = "FAILED"
1458    NOT_SUPPORTED = "NOT_SUPPORTED"
1459    REJECTED = "REJECTED"
1460    TIMEOUT = "TIMEOUT"
1461    UNKNOWN_RESERVATION = "UNKNOWN_RESERVATION"
1462
1463
1464class CommandResult:
1465    message: Optional[List[DisplayText]]
1466    result: CommandResultType
1467
1468    def __init__(self, message: Optional[List[DisplayText]], result: CommandResultType) -> None:
1469        self.message = message
1470        self.result = result
1471
1472    @staticmethod
1473    def from_dict(obj: Any) -> 'CommandResult':
1474        assert isinstance(obj, dict)
1475        message = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("message"))
1476        result = CommandResultType(obj.get("result"))
1477        return CommandResult(message, result)
1478
1479    def to_dict(self) -> dict:
1480        result: dict = {}
1481        if self.message is not None:
1482            result["message"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.message)
1483        result["result"] = to_enum(CommandResultType, self.result)
1484        return result
1485
1486
1487class ConnectorCapability(Enum):
1488    ISO_15118_20__PLUG_AND_CHARGE = "ISO_15118_20_PLUG_AND_CHARGE"
1489    ISO_15118_2__PLUG_AND_CHARGE = "ISO_15118_2_PLUG_AND_CHARGE"
1490
1491
1492class Connector:
1493    capabilities: Optional[List[ConnectorCapability]]
1494    format: ConnectorFormat
1495    id: str
1496    last_updated: str
1497    max_amperage: int
1498    max_electric_power: Optional[int]
1499    max_voltage: int
1500    power_type: PowerType
1501    standard: ConnectorType
1502    tariff_ids: Optional[List[str]]
1503    terms_and_conditions: Optional[str]
1504
1505    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:
1506        self.capabilities = capabilities
1507        self.format = format
1508        self.id = id
1509        self.last_updated = last_updated
1510        self.max_amperage = max_amperage
1511        self.max_electric_power = max_electric_power
1512        self.max_voltage = max_voltage
1513        self.power_type = power_type
1514        self.standard = standard
1515        self.tariff_ids = tariff_ids
1516        self.terms_and_conditions = terms_and_conditions
1517
1518    @staticmethod
1519    def from_dict(obj: Any) -> 'Connector':
1520        assert isinstance(obj, dict)
1521        capabilities = from_union([from_none, lambda x: from_list(ConnectorCapability, x)], obj.get("capabilities"))
1522        format = ConnectorFormat(obj.get("format"))
1523        id = from_str(obj.get("id"))
1524        last_updated = from_str(obj.get("last_updated"))
1525        max_amperage = from_int(obj.get("max_amperage"))
1526        max_electric_power = from_union([from_none, from_int], obj.get("max_electric_power"))
1527        max_voltage = from_int(obj.get("max_voltage"))
1528        power_type = PowerType(obj.get("power_type"))
1529        standard = ConnectorType(obj.get("standard"))
1530        tariff_ids = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("tariff_ids"))
1531        terms_and_conditions = from_union([from_none, from_str], obj.get("terms_and_conditions"))
1532        return Connector(capabilities, format, id, last_updated, max_amperage, max_electric_power, max_voltage, power_type, standard, tariff_ids, terms_and_conditions)
1533
1534    def to_dict(self) -> dict:
1535        result: dict = {}
1536        if self.capabilities is not None:
1537            result["capabilities"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(ConnectorCapability, x), x)], self.capabilities)
1538        result["format"] = to_enum(ConnectorFormat, self.format)
1539        result["id"] = from_str(self.id)
1540        result["last_updated"] = from_str(self.last_updated)
1541        result["max_amperage"] = from_int(self.max_amperage)
1542        if self.max_electric_power is not None:
1543            result["max_electric_power"] = from_union([from_none, from_int], self.max_electric_power)
1544        result["max_voltage"] = from_int(self.max_voltage)
1545        result["power_type"] = to_enum(PowerType, self.power_type)
1546        result["standard"] = to_enum(ConnectorType, self.standard)
1547        if self.tariff_ids is not None:
1548            result["tariff_ids"] = from_union([from_none, lambda x: from_list(from_str, x)], self.tariff_ids)
1549        if self.terms_and_conditions is not None:
1550            result["terms_and_conditions"] = from_union([from_none, from_str], self.terms_and_conditions)
1551        return result
1552
1553
1554class ImageCategory(Enum):
1555    CHARGER = "CHARGER"
1556    ENTRANCE = "ENTRANCE"
1557    LOCATION = "LOCATION"
1558    NETWORK = "NETWORK"
1559    OPERATOR = "OPERATOR"
1560    OTHER = "OTHER"
1561    OWNER = "OWNER"
1562
1563
1564class Image:
1565    category: ImageCategory
1566    height: Optional[int]
1567    thumbnail: Optional[str]
1568    type: str
1569    url: str
1570    width: Optional[int]
1571
1572    def __init__(self, category: ImageCategory, height: Optional[int], thumbnail: Optional[str], type: str, url: str, width: Optional[int]) -> None:
1573        self.category = category
1574        self.height = height
1575        self.thumbnail = thumbnail
1576        self.type = type
1577        self.url = url
1578        self.width = width
1579
1580    @staticmethod
1581    def from_dict(obj: Any) -> 'Image':
1582        assert isinstance(obj, dict)
1583        category = ImageCategory(obj.get("category"))
1584        height = from_union([from_none, from_int], obj.get("height"))
1585        thumbnail = from_union([from_none, from_str], obj.get("thumbnail"))
1586        type = from_str(obj.get("type"))
1587        url = from_str(obj.get("url"))
1588        width = from_union([from_none, from_int], obj.get("width"))
1589        return Image(category, height, thumbnail, type, url, width)
1590
1591    def to_dict(self) -> dict:
1592        result: dict = {}
1593        result["category"] = to_enum(ImageCategory, self.category)
1594        if self.height is not None:
1595            result["height"] = from_union([from_none, from_int], self.height)
1596        if self.thumbnail is not None:
1597            result["thumbnail"] = from_union([from_none, from_str], self.thumbnail)
1598        result["type"] = from_str(self.type)
1599        result["url"] = from_str(self.url)
1600        if self.width is not None:
1601            result["width"] = from_union([from_none, from_int], self.width)
1602        return result
1603
1604
1605class BusinessDetails:
1606    logo: Optional[Image]
1607    name: str
1608    website: Optional[str]
1609
1610    def __init__(self, logo: Optional[Image], name: str, website: Optional[str]) -> None:
1611        self.logo = logo
1612        self.name = name
1613        self.website = website
1614
1615    @staticmethod
1616    def from_dict(obj: Any) -> 'BusinessDetails':
1617        assert isinstance(obj, dict)
1618        logo = from_union([from_none, Image.from_dict], obj.get("logo"))
1619        name = from_str(obj.get("name"))
1620        website = from_union([from_none, from_str], obj.get("website"))
1621        return BusinessDetails(logo, name, website)
1622
1623    def to_dict(self) -> dict:
1624        result: dict = {}
1625        if self.logo is not None:
1626            result["logo"] = from_union([from_none, lambda x: to_class(Image, x)], self.logo)
1627        result["name"] = from_str(self.name)
1628        if self.website is not None:
1629            result["website"] = from_union([from_none, from_str], self.website)
1630        return result
1631
1632
1633class Role(Enum):
1634    CPO = "CPO"
1635    EMSP = "EMSP"
1636    NAP = "NAP"
1637    NSP = "NSP"
1638    OTHER = "OTHER"
1639    SCSP = "SCSP"
1640
1641
1642class CredentialsRole:
1643    business_details: BusinessDetails
1644    country_code: str
1645    party_id: str
1646    role: Role
1647
1648    def __init__(self, business_details: BusinessDetails, country_code: str, party_id: str, role: Role) -> None:
1649        self.business_details = business_details
1650        self.country_code = country_code
1651        self.party_id = party_id
1652        self.role = role
1653
1654    @staticmethod
1655    def from_dict(obj: Any) -> 'CredentialsRole':
1656        assert isinstance(obj, dict)
1657        business_details = BusinessDetails.from_dict(obj.get("business_details"))
1658        country_code = from_str(obj.get("country_code"))
1659        party_id = from_str(obj.get("party_id"))
1660        role = Role(obj.get("role"))
1661        return CredentialsRole(business_details, country_code, party_id, role)
1662
1663    def to_dict(self) -> dict:
1664        result: dict = {}
1665        result["business_details"] = to_class(BusinessDetails, self.business_details)
1666        result["country_code"] = from_str(self.country_code)
1667        result["party_id"] = from_str(self.party_id)
1668        result["role"] = to_enum(Role, self.role)
1669        return result
1670
1671
1672class Credentials:
1673    hub_party_id: Optional[str]
1674    roles: List[CredentialsRole]
1675    token: str
1676    url: str
1677
1678    def __init__(self, hub_party_id: Optional[str], roles: List[CredentialsRole], token: str, url: str) -> None:
1679        self.hub_party_id = hub_party_id
1680        self.roles = roles
1681        self.token = token
1682        self.url = url
1683
1684    @staticmethod
1685    def from_dict(obj: Any) -> 'Credentials':
1686        assert isinstance(obj, dict)
1687        hub_party_id = from_union([from_none, from_str], obj.get("hub_party_id"))
1688        roles = from_list(CredentialsRole.from_dict, obj.get("roles"))
1689        token = from_str(obj.get("token"))
1690        url = from_str(obj.get("url"))
1691        return Credentials(hub_party_id, roles, token, url)
1692
1693    def to_dict(self) -> dict:
1694        result: dict = {}
1695        if self.hub_party_id is not None:
1696            result["hub_party_id"] = from_union([from_none, from_str], self.hub_party_id)
1697        result["roles"] = from_list(lambda x: to_class(CredentialsRole, x), self.roles)
1698        result["token"] = from_str(self.token)
1699        result["url"] = from_str(self.url)
1700        return result
1701
1702
1703class ModuleID(Enum):
1704    CDRS = "cdrs"
1705    CHARGINGPROFILES = "chargingprofiles"
1706    COMMANDS = "commands"
1707    CREDENTIALS = "credentials"
1708    HUBCLIENTINFO = "hubclientinfo"
1709    LOCATIONS = "locations"
1710    PAYMENTS = "payments"
1711    SESSIONS = "sessions"
1712    TARIFFS = "tariffs"
1713    TOKENS = "tokens"
1714
1715
1716class InterfaceRole(Enum):
1717    RECEIVER = "RECEIVER"
1718    SENDER = "SENDER"
1719
1720
1721class Endpoint:
1722    identifier: ModuleID
1723    role: InterfaceRole
1724    url: str
1725
1726    def __init__(self, identifier: ModuleID, role: InterfaceRole, url: str) -> None:
1727        self.identifier = identifier
1728        self.role = role
1729        self.url = url
1730
1731    @staticmethod
1732    def from_dict(obj: Any) -> 'Endpoint':
1733        assert isinstance(obj, dict)
1734        identifier = ModuleID(obj.get("identifier"))
1735        role = InterfaceRole(obj.get("role"))
1736        url = from_str(obj.get("url"))
1737        return Endpoint(identifier, role, url)
1738
1739    def to_dict(self) -> dict:
1740        result: dict = {}
1741        result["identifier"] = to_enum(ModuleID, self.identifier)
1742        result["role"] = to_enum(InterfaceRole, self.role)
1743        result["url"] = from_str(self.url)
1744        return result
1745
1746
1747class Capability(Enum):
1748    CHARGING_PREFERENCES_CAPABLE = "CHARGING_PREFERENCES_CAPABLE"
1749    CHARGING_PROFILE_CAPABLE = "CHARGING_PROFILE_CAPABLE"
1750    CHIP_CARD_SUPPORT = "CHIP_CARD_SUPPORT"
1751    CONTACTLESS_CARD_SUPPORT = "CONTACTLESS_CARD_SUPPORT"
1752    CREDIT_CARD_PAYABLE = "CREDIT_CARD_PAYABLE"
1753    DEBIT_CARD_PAYABLE = "DEBIT_CARD_PAYABLE"
1754    PED_TERMINAL = "PED_TERMINAL"
1755    REMOTE_START_STOP_CAPABLE = "REMOTE_START_STOP_CAPABLE"
1756    RESERVABLE = "RESERVABLE"
1757    RFID_READER = "RFID_READER"
1758    START_SESSION_CONNECTOR_REQUIRED = "START_SESSION_CONNECTOR_REQUIRED"
1759    TOKEN_GROUP_CAPABLE = "TOKEN_GROUP_CAPABLE"
1760    UNLOCK_CAPABLE = "UNLOCK_CAPABLE"
1761
1762
1763class EvsePosition(Enum):
1764    CENTER = "CENTER"
1765    LEFT = "LEFT"
1766    RIGHT = "RIGHT"
1767
1768
1769class EvseParking:
1770    evse_position: Optional[EvsePosition]
1771    parking_id: str
1772
1773    def __init__(self, evse_position: Optional[EvsePosition], parking_id: str) -> None:
1774        self.evse_position = evse_position
1775        self.parking_id = parking_id
1776
1777    @staticmethod
1778    def from_dict(obj: Any) -> 'EvseParking':
1779        assert isinstance(obj, dict)
1780        evse_position = from_union([from_none, EvsePosition], obj.get("evse_position"))
1781        parking_id = from_str(obj.get("parking_id"))
1782        return EvseParking(evse_position, parking_id)
1783
1784    def to_dict(self) -> dict:
1785        result: dict = {}
1786        if self.evse_position is not None:
1787            result["evse_position"] = from_union([from_none, lambda x: to_enum(EvsePosition, x)], self.evse_position)
1788        result["parking_id"] = from_str(self.parking_id)
1789        return result
1790
1791
1792class ParkingRestriction(Enum):
1793    CUSTOMERS = "CUSTOMERS"
1794    DISABLED = "DISABLED"
1795    EMPLOYEES = "EMPLOYEES"
1796    EV_ONLY = "EV_ONLY"
1797    MOTORCYCLES = "MOTORCYCLES"
1798    PLUGGED = "PLUGGED"
1799    TAXIS = "TAXIS"
1800    TENANTS = "TENANTS"
1801
1802
1803class Status(Enum):
1804    AVAILABLE = "AVAILABLE"
1805    BLOCKED = "BLOCKED"
1806    CHARGING = "CHARGING"
1807    INOPERATIVE = "INOPERATIVE"
1808    OUTOFORDER = "OUTOFORDER"
1809    PLANNED = "PLANNED"
1810    REMOVED = "REMOVED"
1811    RESERVED = "RESERVED"
1812    UNKNOWN = "UNKNOWN"
1813
1814
1815class StatusSchedule:
1816    period_begin: str
1817    period_end: Optional[str]
1818    status: Status
1819
1820    def __init__(self, period_begin: str, period_end: Optional[str], status: Status) -> None:
1821        self.period_begin = period_begin
1822        self.period_end = period_end
1823        self.status = status
1824
1825    @staticmethod
1826    def from_dict(obj: Any) -> 'StatusSchedule':
1827        assert isinstance(obj, dict)
1828        period_begin = from_str(obj.get("period_begin"))
1829        period_end = from_union([from_none, from_str], obj.get("period_end"))
1830        status = Status(obj.get("status"))
1831        return StatusSchedule(period_begin, period_end, status)
1832
1833    def to_dict(self) -> dict:
1834        result: dict = {}
1835        result["period_begin"] = from_str(self.period_begin)
1836        if self.period_end is not None:
1837            result["period_end"] = from_union([from_none, from_str], self.period_end)
1838        result["status"] = to_enum(Status, self.status)
1839        return result
1840
1841
1842class Evse:
1843    accepted_service_providers: Optional[List[str]]
1844    capabilities: Optional[List[Capability]]
1845    connectors: List[Connector]
1846    coordinates: Optional[GeoLocation]
1847    directions: Optional[List[DisplayText]]
1848    evse_id: Optional[str]
1849    floor_level: Optional[str]
1850    images: Optional[List[Image]]
1851    last_updated: str
1852    parking: Optional[List[EvseParking]]
1853    parking_restrictions: Optional[List[ParkingRestriction]]
1854    physical_reference: Optional[str]
1855    status: Status
1856    status_schedule: Optional[List[StatusSchedule]]
1857    uid: str
1858
1859    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:
1860        self.accepted_service_providers = accepted_service_providers
1861        self.capabilities = capabilities
1862        self.connectors = connectors
1863        self.coordinates = coordinates
1864        self.directions = directions
1865        self.evse_id = evse_id
1866        self.floor_level = floor_level
1867        self.images = images
1868        self.last_updated = last_updated
1869        self.parking = parking
1870        self.parking_restrictions = parking_restrictions
1871        self.physical_reference = physical_reference
1872        self.status = status
1873        self.status_schedule = status_schedule
1874        self.uid = uid
1875
1876    @staticmethod
1877    def from_dict(obj: Any) -> 'Evse':
1878        assert isinstance(obj, dict)
1879        accepted_service_providers = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("accepted_service_providers"))
1880        capabilities = from_union([from_none, lambda x: from_list(Capability, x)], obj.get("capabilities"))
1881        connectors = from_list(Connector.from_dict, obj.get("connectors"))
1882        coordinates = from_union([from_none, GeoLocation.from_dict], obj.get("coordinates"))
1883        directions = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("directions"))
1884        evse_id = from_union([from_none, from_str], obj.get("evse_id"))
1885        floor_level = from_union([from_none, from_str], obj.get("floor_level"))
1886        images = from_union([from_none, lambda x: from_list(Image.from_dict, x)], obj.get("images"))
1887        last_updated = from_str(obj.get("last_updated"))
1888        parking = from_union([from_none, lambda x: from_list(EvseParking.from_dict, x)], obj.get("parking"))
1889        parking_restrictions = from_union([from_none, lambda x: from_list(ParkingRestriction, x)], obj.get("parking_restrictions"))
1890        physical_reference = from_union([from_none, from_str], obj.get("physical_reference"))
1891        status = Status(obj.get("status"))
1892        status_schedule = from_union([from_none, lambda x: from_list(StatusSchedule.from_dict, x)], obj.get("status_schedule"))
1893        uid = from_str(obj.get("uid"))
1894        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)
1895
1896    def to_dict(self) -> dict:
1897        result: dict = {}
1898        if self.accepted_service_providers is not None:
1899            result["accepted_service_providers"] = from_union([from_none, lambda x: from_list(from_str, x)], self.accepted_service_providers)
1900        if self.capabilities is not None:
1901            result["capabilities"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(Capability, x), x)], self.capabilities)
1902        result["connectors"] = from_list(lambda x: to_class(Connector, x), self.connectors)
1903        if self.coordinates is not None:
1904            result["coordinates"] = from_union([from_none, lambda x: to_class(GeoLocation, x)], self.coordinates)
1905        if self.directions is not None:
1906            result["directions"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.directions)
1907        if self.evse_id is not None:
1908            result["evse_id"] = from_union([from_none, from_str], self.evse_id)
1909        if self.floor_level is not None:
1910            result["floor_level"] = from_union([from_none, from_str], self.floor_level)
1911        if self.images is not None:
1912            result["images"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Image, x), x)], self.images)
1913        result["last_updated"] = from_str(self.last_updated)
1914        if self.parking is not None:
1915            result["parking"] = from_union([from_none, lambda x: from_list(lambda x: to_class(EvseParking, x), x)], self.parking)
1916        if self.parking_restrictions is not None:
1917            result["parking_restrictions"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(ParkingRestriction, x), x)], self.parking_restrictions)
1918        if self.physical_reference is not None:
1919            result["physical_reference"] = from_union([from_none, from_str], self.physical_reference)
1920        result["status"] = to_enum(Status, self.status)
1921        if self.status_schedule is not None:
1922            result["status_schedule"] = from_union([from_none, lambda x: from_list(lambda x: to_class(StatusSchedule, x), x)], self.status_schedule)
1923        result["uid"] = from_str(self.uid)
1924        return result
1925
1926
1927class CaptureStatusCode(Enum):
1928    FAILED = "FAILED"
1929    PARTIAL_SUCCESS = "PARTIAL_SUCCESS"
1930    SUCCESS = "SUCCESS"
1931
1932
1933class FinancialAdviceConfirmation:
1934    authorization_reference: str
1935    capture_status_code: CaptureStatusCode
1936    capture_status_message: Optional[str]
1937    currency: str
1938    eft_data: List[str]
1939    id: str
1940    last_updated: str
1941    total_costs: Price
1942
1943    def __init__(self, authorization_reference: str, capture_status_code: CaptureStatusCode, capture_status_message: Optional[str], currency: str, eft_data: List[str], id: str, last_updated: str, total_costs: Price) -> None:
1944        self.authorization_reference = authorization_reference
1945        self.capture_status_code = capture_status_code
1946        self.capture_status_message = capture_status_message
1947        self.currency = currency
1948        self.eft_data = eft_data
1949        self.id = id
1950        self.last_updated = last_updated
1951        self.total_costs = total_costs
1952
1953    @staticmethod
1954    def from_dict(obj: Any) -> 'FinancialAdviceConfirmation':
1955        assert isinstance(obj, dict)
1956        authorization_reference = from_str(obj.get("authorization_reference"))
1957        capture_status_code = CaptureStatusCode(obj.get("capture_status_code"))
1958        capture_status_message = from_union([from_none, from_str], obj.get("capture_status_message"))
1959        currency = from_str(obj.get("currency"))
1960        eft_data = from_list(from_str, obj.get("eft_data"))
1961        id = from_str(obj.get("id"))
1962        last_updated = from_str(obj.get("last_updated"))
1963        total_costs = Price.from_dict(obj.get("total_costs"))
1964        return FinancialAdviceConfirmation(authorization_reference, capture_status_code, capture_status_message, currency, eft_data, id, last_updated, total_costs)
1965
1966    def to_dict(self) -> dict:
1967        result: dict = {}
1968        result["authorization_reference"] = from_str(self.authorization_reference)
1969        result["capture_status_code"] = to_enum(CaptureStatusCode, self.capture_status_code)
1970        if self.capture_status_message is not None:
1971            result["capture_status_message"] = from_union([from_none, from_str], self.capture_status_message)
1972        result["currency"] = from_str(self.currency)
1973        result["eft_data"] = from_list(from_str, self.eft_data)
1974        result["id"] = from_str(self.id)
1975        result["last_updated"] = from_str(self.last_updated)
1976        result["total_costs"] = to_class(Price, self.total_costs)
1977        return result
1978
1979
1980class ConnectionStatus(Enum):
1981    CONNECTED = "CONNECTED"
1982    OFFLINE = "OFFLINE"
1983    PLANNED = "PLANNED"
1984    SUSPENDED = "SUSPENDED"
1985
1986
1987class HubClientInfo:
1988    country_code: str
1989    last_updated: str
1990    party_id: str
1991    role: Role
1992    status: ConnectionStatus
1993
1994    def __init__(self, country_code: str, last_updated: str, party_id: str, role: Role, status: ConnectionStatus) -> None:
1995        self.country_code = country_code
1996        self.last_updated = last_updated
1997        self.party_id = party_id
1998        self.role = role
1999        self.status = status
2000
2001    @staticmethod
2002    def from_dict(obj: Any) -> 'HubClientInfo':
2003        assert isinstance(obj, dict)
2004        country_code = from_str(obj.get("country_code"))
2005        last_updated = from_str(obj.get("last_updated"))
2006        party_id = from_str(obj.get("party_id"))
2007        role = Role(obj.get("role"))
2008        status = ConnectionStatus(obj.get("status"))
2009        return HubClientInfo(country_code, last_updated, party_id, role, status)
2010
2011    def to_dict(self) -> dict:
2012        result: dict = {}
2013        result["country_code"] = from_str(self.country_code)
2014        result["last_updated"] = from_str(self.last_updated)
2015        result["party_id"] = from_str(self.party_id)
2016        result["role"] = to_enum(Role, self.role)
2017        result["status"] = to_enum(ConnectionStatus, self.status)
2018        return result
2019
2020
2021class Facility(Enum):
2022    AIRPORT = "AIRPORT"
2023    BIKE_SHARING = "BIKE_SHARING"
2024    BUS_STOP = "BUS_STOP"
2025    CAFE = "CAFE"
2026    CARPOOL_PARKING = "CARPOOL_PARKING"
2027    FUEL_STATION = "FUEL_STATION"
2028    HOTEL = "HOTEL"
2029    MALL = "MALL"
2030    METRO_STATION = "METRO_STATION"
2031    MUSEUM = "MUSEUM"
2032    NATURE = "NATURE"
2033    PARKING_LOT = "PARKING_LOT"
2034    RECREATION_AREA = "RECREATION_AREA"
2035    RESTAURANT = "RESTAURANT"
2036    SPORT = "SPORT"
2037    SUPERMARKET = "SUPERMARKET"
2038    TAXI_STAND = "TAXI_STAND"
2039    TRAIN_STATION = "TRAIN_STATION"
2040    TRAM_STOP = "TRAM_STOP"
2041    WIFI = "WIFI"
2042
2043
2044class ExceptionalPeriod:
2045    period_begin: str
2046    period_end: str
2047
2048    def __init__(self, period_begin: str, period_end: str) -> None:
2049        self.period_begin = period_begin
2050        self.period_end = period_end
2051
2052    @staticmethod
2053    def from_dict(obj: Any) -> 'ExceptionalPeriod':
2054        assert isinstance(obj, dict)
2055        period_begin = from_str(obj.get("period_begin"))
2056        period_end = from_str(obj.get("period_end"))
2057        return ExceptionalPeriod(period_begin, period_end)
2058
2059    def to_dict(self) -> dict:
2060        result: dict = {}
2061        result["period_begin"] = from_str(self.period_begin)
2062        result["period_end"] = from_str(self.period_end)
2063        return result
2064
2065
2066class RegularHours:
2067    period_begin: str
2068    period_end: str
2069    weekday: int
2070
2071    def __init__(self, period_begin: str, period_end: str, weekday: int) -> None:
2072        self.period_begin = period_begin
2073        self.period_end = period_end
2074        self.weekday = weekday
2075
2076    @staticmethod
2077    def from_dict(obj: Any) -> 'RegularHours':
2078        assert isinstance(obj, dict)
2079        period_begin = from_str(obj.get("period_begin"))
2080        period_end = from_str(obj.get("period_end"))
2081        weekday = from_int(obj.get("weekday"))
2082        return RegularHours(period_begin, period_end, weekday)
2083
2084    def to_dict(self) -> dict:
2085        result: dict = {}
2086        result["period_begin"] = from_str(self.period_begin)
2087        result["period_end"] = from_str(self.period_end)
2088        result["weekday"] = from_int(self.weekday)
2089        return result
2090
2091
2092class Hours:
2093    exceptional_closings: Optional[List[ExceptionalPeriod]]
2094    exceptional_openings: Optional[List[ExceptionalPeriod]]
2095    regular_hours: Optional[List[RegularHours]]
2096    twentyfourseven: bool
2097
2098    def __init__(self, exceptional_closings: Optional[List[ExceptionalPeriod]], exceptional_openings: Optional[List[ExceptionalPeriod]], regular_hours: Optional[List[RegularHours]], twentyfourseven: bool) -> None:
2099        self.exceptional_closings = exceptional_closings
2100        self.exceptional_openings = exceptional_openings
2101        self.regular_hours = regular_hours
2102        self.twentyfourseven = twentyfourseven
2103
2104    @staticmethod
2105    def from_dict(obj: Any) -> 'Hours':
2106        assert isinstance(obj, dict)
2107        exceptional_closings = from_union([from_none, lambda x: from_list(ExceptionalPeriod.from_dict, x)], obj.get("exceptional_closings"))
2108        exceptional_openings = from_union([from_none, lambda x: from_list(ExceptionalPeriod.from_dict, x)], obj.get("exceptional_openings"))
2109        regular_hours = from_union([from_none, lambda x: from_list(RegularHours.from_dict, x)], obj.get("regular_hours"))
2110        twentyfourseven = from_bool(obj.get("twentyfourseven"))
2111        return Hours(exceptional_closings, exceptional_openings, regular_hours, twentyfourseven)
2112
2113    def to_dict(self) -> dict:
2114        result: dict = {}
2115        if self.exceptional_closings is not None:
2116            result["exceptional_closings"] = from_union([from_none, lambda x: from_list(lambda x: to_class(ExceptionalPeriod, x), x)], self.exceptional_closings)
2117        if self.exceptional_openings is not None:
2118            result["exceptional_openings"] = from_union([from_none, lambda x: from_list(lambda x: to_class(ExceptionalPeriod, x), x)], self.exceptional_openings)
2119        if self.regular_hours is not None:
2120            result["regular_hours"] = from_union([from_none, lambda x: from_list(lambda x: to_class(RegularHours, x), x)], self.regular_hours)
2121        result["twentyfourseven"] = from_bool(self.twentyfourseven)
2122        return result
2123
2124
2125class ParkingDirection(Enum):
2126    ANGLE = "ANGLE"
2127    PARALLEL = "PARALLEL"
2128    PERPENDICULAR = "PERPENDICULAR"
2129
2130
2131class VehicleType(Enum):
2132    BUS = "BUS"
2133    DISABLED = "DISABLED"
2134    MOTORCYCLE = "MOTORCYCLE"
2135    PERSONAL_VEHICLE = "PERSONAL_VEHICLE"
2136    PERSONAL_VEHICLE_WITH_TRAILER = "PERSONAL_VEHICLE_WITH_TRAILER"
2137    RIGID = "RIGID"
2138    SEMI_TRACTOR = "SEMI_TRACTOR"
2139    TRUCK_WITH_TRAILER = "TRUCK_WITH_TRAILER"
2140    VAN = "VAN"
2141
2142
2143class Parking:
2144    apds_reference: Optional[str]
2145    dangerous_goods_allowed: Optional[bool]
2146    direction: Optional[ParkingDirection]
2147    drive_through: Optional[bool]
2148    id: str
2149    images: Optional[List[Image]]
2150    lighting: Optional[bool]
2151    max_vehicle_height: Optional[float]
2152    max_vehicle_length: Optional[float]
2153    max_vehicle_weight: Optional[float]
2154    max_vehicle_width: Optional[float]
2155    parking_space_length: Optional[float]
2156    parking_space_width: Optional[float]
2157    physical_reference: Optional[str]
2158    refrigeration_outlet: Optional[bool]
2159    reservation_required: bool
2160    restricted_to_type: bool
2161    roofed: Optional[bool]
2162    standards: Optional[List[str]]
2163    time_limit: Optional[float]
2164    vehicle_types: List[VehicleType]
2165
2166    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:
2167        self.apds_reference = apds_reference
2168        self.dangerous_goods_allowed = dangerous_goods_allowed
2169        self.direction = direction
2170        self.drive_through = drive_through
2171        self.id = id
2172        self.images = images
2173        self.lighting = lighting
2174        self.max_vehicle_height = max_vehicle_height
2175        self.max_vehicle_length = max_vehicle_length
2176        self.max_vehicle_weight = max_vehicle_weight
2177        self.max_vehicle_width = max_vehicle_width
2178        self.parking_space_length = parking_space_length
2179        self.parking_space_width = parking_space_width
2180        self.physical_reference = physical_reference
2181        self.refrigeration_outlet = refrigeration_outlet
2182        self.reservation_required = reservation_required
2183        self.restricted_to_type = restricted_to_type
2184        self.roofed = roofed
2185        self.standards = standards
2186        self.time_limit = time_limit
2187        self.vehicle_types = vehicle_types
2188
2189    @staticmethod
2190    def from_dict(obj: Any) -> 'Parking':
2191        assert isinstance(obj, dict)
2192        apds_reference = from_union([from_none, from_str], obj.get("apds_reference"))
2193        dangerous_goods_allowed = from_union([from_none, from_bool], obj.get("dangerous_goods_allowed"))
2194        direction = from_union([from_none, ParkingDirection], obj.get("direction"))
2195        drive_through = from_union([from_none, from_bool], obj.get("drive_through"))
2196        id = from_str(obj.get("id"))
2197        images = from_union([from_none, lambda x: from_list(Image.from_dict, x)], obj.get("images"))
2198        lighting = from_union([from_none, from_bool], obj.get("lighting"))
2199        max_vehicle_height = from_union([from_none, from_float], obj.get("max_vehicle_height"))
2200        max_vehicle_length = from_union([from_none, from_float], obj.get("max_vehicle_length"))
2201        max_vehicle_weight = from_union([from_none, from_float], obj.get("max_vehicle_weight"))
2202        max_vehicle_width = from_union([from_none, from_float], obj.get("max_vehicle_width"))
2203        parking_space_length = from_union([from_none, from_float], obj.get("parking_space_length"))
2204        parking_space_width = from_union([from_none, from_float], obj.get("parking_space_width"))
2205        physical_reference = from_union([from_none, from_str], obj.get("physical_reference"))
2206        refrigeration_outlet = from_union([from_none, from_bool], obj.get("refrigeration_outlet"))
2207        reservation_required = from_bool(obj.get("reservation_required"))
2208        restricted_to_type = from_bool(obj.get("restricted_to_type"))
2209        roofed = from_union([from_none, from_bool], obj.get("roofed"))
2210        standards = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("standards"))
2211        time_limit = from_union([from_none, from_float], obj.get("time_limit"))
2212        vehicle_types = from_list(VehicleType, obj.get("vehicle_types"))
2213        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)
2214
2215    def to_dict(self) -> dict:
2216        result: dict = {}
2217        if self.apds_reference is not None:
2218            result["apds_reference"] = from_union([from_none, from_str], self.apds_reference)
2219        if self.dangerous_goods_allowed is not None:
2220            result["dangerous_goods_allowed"] = from_union([from_none, from_bool], self.dangerous_goods_allowed)
2221        if self.direction is not None:
2222            result["direction"] = from_union([from_none, lambda x: to_enum(ParkingDirection, x)], self.direction)
2223        if self.drive_through is not None:
2224            result["drive_through"] = from_union([from_none, from_bool], self.drive_through)
2225        result["id"] = from_str(self.id)
2226        if self.images is not None:
2227            result["images"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Image, x), x)], self.images)
2228        if self.lighting is not None:
2229            result["lighting"] = from_union([from_none, from_bool], self.lighting)
2230        if self.max_vehicle_height is not None:
2231            result["max_vehicle_height"] = from_union([from_none, to_float], self.max_vehicle_height)
2232        if self.max_vehicle_length is not None:
2233            result["max_vehicle_length"] = from_union([from_none, to_float], self.max_vehicle_length)
2234        if self.max_vehicle_weight is not None:
2235            result["max_vehicle_weight"] = from_union([from_none, to_float], self.max_vehicle_weight)
2236        if self.max_vehicle_width is not None:
2237            result["max_vehicle_width"] = from_union([from_none, to_float], self.max_vehicle_width)
2238        if self.parking_space_length is not None:
2239            result["parking_space_length"] = from_union([from_none, to_float], self.parking_space_length)
2240        if self.parking_space_width is not None:
2241            result["parking_space_width"] = from_union([from_none, to_float], self.parking_space_width)
2242        if self.physical_reference is not None:
2243            result["physical_reference"] = from_union([from_none, from_str], self.physical_reference)
2244        if self.refrigeration_outlet is not None:
2245            result["refrigeration_outlet"] = from_union([from_none, from_bool], self.refrigeration_outlet)
2246        result["reservation_required"] = from_bool(self.reservation_required)
2247        result["restricted_to_type"] = from_bool(self.restricted_to_type)
2248        if self.roofed is not None:
2249            result["roofed"] = from_union([from_none, from_bool], self.roofed)
2250        if self.standards is not None:
2251            result["standards"] = from_union([from_none, lambda x: from_list(from_str, x)], self.standards)
2252        if self.time_limit is not None:
2253            result["time_limit"] = from_union([from_none, to_float], self.time_limit)
2254        result["vehicle_types"] = from_list(lambda x: to_enum(VehicleType, x), self.vehicle_types)
2255        return result
2256
2257
2258class ParkingType(Enum):
2259    ALONG_MOTORWAY = "ALONG_MOTORWAY"
2260    ON_DRIVEWAY = "ON_DRIVEWAY"
2261    ON_STREET = "ON_STREET"
2262    PARKING_GARAGE = "PARKING_GARAGE"
2263    PARKING_LOT = "PARKING_LOT"
2264    UNDERGROUND_GARAGE = "UNDERGROUND_GARAGE"
2265
2266
2267class PublishTokenType:
2268    group_id: Optional[str]
2269    issuer: Optional[str]
2270    type: Optional[TokenType]
2271    uid: Optional[str]
2272    visual_number: Optional[str]
2273
2274    def __init__(self, group_id: Optional[str], issuer: Optional[str], type: Optional[TokenType], uid: Optional[str], visual_number: Optional[str]) -> None:
2275        self.group_id = group_id
2276        self.issuer = issuer
2277        self.type = type
2278        self.uid = uid
2279        self.visual_number = visual_number
2280
2281    @staticmethod
2282    def from_dict(obj: Any) -> 'PublishTokenType':
2283        assert isinstance(obj, dict)
2284        group_id = from_union([from_none, from_str], obj.get("group_id"))
2285        issuer = from_union([from_none, from_str], obj.get("issuer"))
2286        type = from_union([from_none, TokenType], obj.get("type"))
2287        uid = from_union([from_none, from_str], obj.get("uid"))
2288        visual_number = from_union([from_none, from_str], obj.get("visual_number"))
2289        return PublishTokenType(group_id, issuer, type, uid, visual_number)
2290
2291    def to_dict(self) -> dict:
2292        result: dict = {}
2293        if self.group_id is not None:
2294            result["group_id"] = from_union([from_none, from_str], self.group_id)
2295        if self.issuer is not None:
2296            result["issuer"] = from_union([from_none, from_str], self.issuer)
2297        if self.type is not None:
2298            result["type"] = from_union([from_none, lambda x: to_enum(TokenType, x)], self.type)
2299        if self.uid is not None:
2300            result["uid"] = from_union([from_none, from_str], self.uid)
2301        if self.visual_number is not None:
2302            result["visual_number"] = from_union([from_none, from_str], self.visual_number)
2303        return result
2304
2305
2306class AdditionalGeoLocation:
2307    latitude: str
2308    longitude: str
2309    name: Optional[DisplayText]
2310
2311    def __init__(self, latitude: str, longitude: str, name: Optional[DisplayText]) -> None:
2312        self.latitude = latitude
2313        self.longitude = longitude
2314        self.name = name
2315
2316    @staticmethod
2317    def from_dict(obj: Any) -> 'AdditionalGeoLocation':
2318        assert isinstance(obj, dict)
2319        latitude = from_str(obj.get("latitude"))
2320        longitude = from_str(obj.get("longitude"))
2321        name = from_union([from_none, DisplayText.from_dict], obj.get("name"))
2322        return AdditionalGeoLocation(latitude, longitude, name)
2323
2324    def to_dict(self) -> dict:
2325        result: dict = {}
2326        result["latitude"] = from_str(self.latitude)
2327        result["longitude"] = from_str(self.longitude)
2328        if self.name is not None:
2329            result["name"] = from_union([from_none, lambda x: to_class(DisplayText, x)], self.name)
2330        return result
2331
2332
2333class Location:
2334    address: str
2335    charging_when_closed: Optional[bool]
2336    city: str
2337    coordinates: GeoLocation
2338    country: str
2339    country_code: str
2340    directions: Optional[List[DisplayText]]
2341    energy_mix: Optional[EnergyMix]
2342    evses: Optional[List[Evse]]
2343    facilities: Optional[List[Facility]]
2344    help_phone: Optional[str]
2345    id: str
2346    images: Optional[List[Image]]
2347    last_updated: str
2348    name: Optional[str]
2349    opening_times: Optional[Hours]
2350    operator: Optional[BusinessDetails]
2351    owner: Optional[BusinessDetails]
2352    parking_places: Optional[List[Parking]]
2353    parking_type: Optional[ParkingType]
2354    party_id: str
2355    postal_code: Optional[str]
2356    publish: bool
2357    publish_allowed_to: Optional[List[PublishTokenType]]
2358    related_locations: Optional[List[AdditionalGeoLocation]]
2359    state: Optional[str]
2360    suboperator: Optional[BusinessDetails]
2361    time_zone: str
2362
2363    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:
2364        self.address = address
2365        self.charging_when_closed = charging_when_closed
2366        self.city = city
2367        self.coordinates = coordinates
2368        self.country = country
2369        self.country_code = country_code
2370        self.directions = directions
2371        self.energy_mix = energy_mix
2372        self.evses = evses
2373        self.facilities = facilities
2374        self.help_phone = help_phone
2375        self.id = id
2376        self.images = images
2377        self.last_updated = last_updated
2378        self.name = name
2379        self.opening_times = opening_times
2380        self.operator = operator
2381        self.owner = owner
2382        self.parking_places = parking_places
2383        self.parking_type = parking_type
2384        self.party_id = party_id
2385        self.postal_code = postal_code
2386        self.publish = publish
2387        self.publish_allowed_to = publish_allowed_to
2388        self.related_locations = related_locations
2389        self.state = state
2390        self.suboperator = suboperator
2391        self.time_zone = time_zone
2392
2393    @staticmethod
2394    def from_dict(obj: Any) -> 'Location':
2395        assert isinstance(obj, dict)
2396        address = from_str(obj.get("address"))
2397        charging_when_closed = from_union([from_none, from_bool], obj.get("charging_when_closed"))
2398        city = from_str(obj.get("city"))
2399        coordinates = GeoLocation.from_dict(obj.get("coordinates"))
2400        country = from_str(obj.get("country"))
2401        country_code = from_str(obj.get("country_code"))
2402        directions = from_union([from_none, lambda x: from_list(DisplayText.from_dict, x)], obj.get("directions"))
2403        energy_mix = from_union([from_none, EnergyMix.from_dict], obj.get("energy_mix"))
2404        evses = from_union([from_none, lambda x: from_list(Evse.from_dict, x)], obj.get("evses"))
2405        facilities = from_union([from_none, lambda x: from_list(Facility, x)], obj.get("facilities"))
2406        help_phone = from_union([from_none, from_str], obj.get("help_phone"))
2407        id = from_str(obj.get("id"))
2408        images = from_union([from_none, lambda x: from_list(Image.from_dict, x)], obj.get("images"))
2409        last_updated = from_str(obj.get("last_updated"))
2410        name = from_union([from_none, from_str], obj.get("name"))
2411        opening_times = from_union([from_none, Hours.from_dict], obj.get("opening_times"))
2412        operator = from_union([from_none, BusinessDetails.from_dict], obj.get("operator"))
2413        owner = from_union([from_none, BusinessDetails.from_dict], obj.get("owner"))
2414        parking_places = from_union([from_none, lambda x: from_list(Parking.from_dict, x)], obj.get("parking_places"))
2415        parking_type = from_union([from_none, ParkingType], obj.get("parking_type"))
2416        party_id = from_str(obj.get("party_id"))
2417        postal_code = from_union([from_none, from_str], obj.get("postal_code"))
2418        publish = from_bool(obj.get("publish"))
2419        publish_allowed_to = from_union([from_none, lambda x: from_list(PublishTokenType.from_dict, x)], obj.get("publish_allowed_to"))
2420        related_locations = from_union([from_none, lambda x: from_list(AdditionalGeoLocation.from_dict, x)], obj.get("related_locations"))
2421        state = from_union([from_none, from_str], obj.get("state"))
2422        suboperator = from_union([from_none, BusinessDetails.from_dict], obj.get("suboperator"))
2423        time_zone = from_str(obj.get("time_zone"))
2424        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)
2425
2426    def to_dict(self) -> dict:
2427        result: dict = {}
2428        result["address"] = from_str(self.address)
2429        if self.charging_when_closed is not None:
2430            result["charging_when_closed"] = from_union([from_none, from_bool], self.charging_when_closed)
2431        result["city"] = from_str(self.city)
2432        result["coordinates"] = to_class(GeoLocation, self.coordinates)
2433        result["country"] = from_str(self.country)
2434        result["country_code"] = from_str(self.country_code)
2435        if self.directions is not None:
2436            result["directions"] = from_union([from_none, lambda x: from_list(lambda x: to_class(DisplayText, x), x)], self.directions)
2437        if self.energy_mix is not None:
2438            result["energy_mix"] = from_union([from_none, lambda x: to_class(EnergyMix, x)], self.energy_mix)
2439        if self.evses is not None:
2440            result["evses"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Evse, x), x)], self.evses)
2441        if self.facilities is not None:
2442            result["facilities"] = from_union([from_none, lambda x: from_list(lambda x: to_enum(Facility, x), x)], self.facilities)
2443        if self.help_phone is not None:
2444            result["help_phone"] = from_union([from_none, from_str], self.help_phone)
2445        result["id"] = from_str(self.id)
2446        if self.images is not None:
2447            result["images"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Image, x), x)], self.images)
2448        result["last_updated"] = from_str(self.last_updated)
2449        if self.name is not None:
2450            result["name"] = from_union([from_none, from_str], self.name)
2451        if self.opening_times is not None:
2452            result["opening_times"] = from_union([from_none, lambda x: to_class(Hours, x)], self.opening_times)
2453        if self.operator is not None:
2454            result["operator"] = from_union([from_none, lambda x: to_class(BusinessDetails, x)], self.operator)
2455        if self.owner is not None:
2456            result["owner"] = from_union([from_none, lambda x: to_class(BusinessDetails, x)], self.owner)
2457        if self.parking_places is not None:
2458            result["parking_places"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Parking, x), x)], self.parking_places)
2459        if self.parking_type is not None:
2460            result["parking_type"] = from_union([from_none, lambda x: to_enum(ParkingType, x)], self.parking_type)
2461        result["party_id"] = from_str(self.party_id)
2462        if self.postal_code is not None:
2463            result["postal_code"] = from_union([from_none, from_str], self.postal_code)
2464        result["publish"] = from_bool(self.publish)
2465        if self.publish_allowed_to is not None:
2466            result["publish_allowed_to"] = from_union([from_none, lambda x: from_list(lambda x: to_class(PublishTokenType, x), x)], self.publish_allowed_to)
2467        if self.related_locations is not None:
2468            result["related_locations"] = from_union([from_none, lambda x: from_list(lambda x: to_class(AdditionalGeoLocation, x), x)], self.related_locations)
2469        if self.state is not None:
2470            result["state"] = from_union([from_none, from_str], self.state)
2471        if self.suboperator is not None:
2472            result["suboperator"] = from_union([from_none, lambda x: to_class(BusinessDetails, x)], self.suboperator)
2473        result["time_zone"] = from_str(self.time_zone)
2474        return result
2475
2476
2477class ReserveNow:
2478    authorization_reference: Optional[str]
2479    evse_uid: Optional[str]
2480    expiry_date: str
2481    location_id: str
2482    reservation_id: str
2483    response_url: str
2484    token: Token
2485
2486    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:
2487        self.authorization_reference = authorization_reference
2488        self.evse_uid = evse_uid
2489        self.expiry_date = expiry_date
2490        self.location_id = location_id
2491        self.reservation_id = reservation_id
2492        self.response_url = response_url
2493        self.token = token
2494
2495    @staticmethod
2496    def from_dict(obj: Any) -> 'ReserveNow':
2497        assert isinstance(obj, dict)
2498        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
2499        evse_uid = from_union([from_none, from_str], obj.get("evse_uid"))
2500        expiry_date = from_str(obj.get("expiry_date"))
2501        location_id = from_str(obj.get("location_id"))
2502        reservation_id = from_str(obj.get("reservation_id"))
2503        response_url = from_str(obj.get("response_url"))
2504        token = Token.from_dict(obj.get("token"))
2505        return ReserveNow(authorization_reference, evse_uid, expiry_date, location_id, reservation_id, response_url, token)
2506
2507    def to_dict(self) -> dict:
2508        result: dict = {}
2509        if self.authorization_reference is not None:
2510            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
2511        if self.evse_uid is not None:
2512            result["evse_uid"] = from_union([from_none, from_str], self.evse_uid)
2513        result["expiry_date"] = from_str(self.expiry_date)
2514        result["location_id"] = from_str(self.location_id)
2515        result["reservation_id"] = from_str(self.reservation_id)
2516        result["response_url"] = from_str(self.response_url)
2517        result["token"] = to_class(Token, self.token)
2518        return result
2519
2520
2521class SessionStatus(Enum):
2522    ACTIVE = "ACTIVE"
2523    COMPLETED = "COMPLETED"
2524    INVALID = "INVALID"
2525    PENDING = "PENDING"
2526    RESERVATION = "RESERVATION"
2527
2528
2529class Session:
2530    auth_method: AuthMethod
2531    authorization_reference: Optional[str]
2532    cdr_token: CdrToken
2533    charging_periods: Optional[List[ChargingPeriod]]
2534    connector_id: str
2535    country_code: str
2536    currency: str
2537    end_date_time: Optional[str]
2538    evse_uid: str
2539    id: str
2540    kwh: float
2541    last_updated: str
2542    location_id: str
2543    meter_id: Optional[str]
2544    party_id: str
2545    start_date_time: str
2546    status: SessionStatus
2547    total_cost: Optional[Price]
2548
2549    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:
2550        self.auth_method = auth_method
2551        self.authorization_reference = authorization_reference
2552        self.cdr_token = cdr_token
2553        self.charging_periods = charging_periods
2554        self.connector_id = connector_id
2555        self.country_code = country_code
2556        self.currency = currency
2557        self.end_date_time = end_date_time
2558        self.evse_uid = evse_uid
2559        self.id = id
2560        self.kwh = kwh
2561        self.last_updated = last_updated
2562        self.location_id = location_id
2563        self.meter_id = meter_id
2564        self.party_id = party_id
2565        self.start_date_time = start_date_time
2566        self.status = status
2567        self.total_cost = total_cost
2568
2569    @staticmethod
2570    def from_dict(obj: Any) -> 'Session':
2571        assert isinstance(obj, dict)
2572        auth_method = AuthMethod(obj.get("auth_method"))
2573        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
2574        cdr_token = CdrToken.from_dict(obj.get("cdr_token"))
2575        charging_periods = from_union([from_none, lambda x: from_list(ChargingPeriod.from_dict, x)], obj.get("charging_periods"))
2576        connector_id = from_str(obj.get("connector_id"))
2577        country_code = from_str(obj.get("country_code"))
2578        currency = from_str(obj.get("currency"))
2579        end_date_time = from_union([from_none, from_str], obj.get("end_date_time"))
2580        evse_uid = from_str(obj.get("evse_uid"))
2581        id = from_str(obj.get("id"))
2582        kwh = from_float(obj.get("kwh"))
2583        last_updated = from_str(obj.get("last_updated"))
2584        location_id = from_str(obj.get("location_id"))
2585        meter_id = from_union([from_none, from_str], obj.get("meter_id"))
2586        party_id = from_str(obj.get("party_id"))
2587        start_date_time = from_str(obj.get("start_date_time"))
2588        status = SessionStatus(obj.get("status"))
2589        total_cost = from_union([from_none, Price.from_dict], obj.get("total_cost"))
2590        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)
2591
2592    def to_dict(self) -> dict:
2593        result: dict = {}
2594        result["auth_method"] = to_enum(AuthMethod, self.auth_method)
2595        if self.authorization_reference is not None:
2596            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
2597        result["cdr_token"] = to_class(CdrToken, self.cdr_token)
2598        if self.charging_periods is not None:
2599            result["charging_periods"] = from_union([from_none, lambda x: from_list(lambda x: to_class(ChargingPeriod, x), x)], self.charging_periods)
2600        result["connector_id"] = from_str(self.connector_id)
2601        result["country_code"] = from_str(self.country_code)
2602        result["currency"] = from_str(self.currency)
2603        if self.end_date_time is not None:
2604            result["end_date_time"] = from_union([from_none, from_str], self.end_date_time)
2605        result["evse_uid"] = from_str(self.evse_uid)
2606        result["id"] = from_str(self.id)
2607        result["kwh"] = to_float(self.kwh)
2608        result["last_updated"] = from_str(self.last_updated)
2609        result["location_id"] = from_str(self.location_id)
2610        if self.meter_id is not None:
2611            result["meter_id"] = from_union([from_none, from_str], self.meter_id)
2612        result["party_id"] = from_str(self.party_id)
2613        result["start_date_time"] = from_str(self.start_date_time)
2614        result["status"] = to_enum(SessionStatus, self.status)
2615        if self.total_cost is not None:
2616            result["total_cost"] = from_union([from_none, lambda x: to_class(Price, x)], self.total_cost)
2617        return result
2618
2619
2620class SetChargingProfile:
2621    charging_profile: ChargingProfile
2622    response_url: str
2623
2624    def __init__(self, charging_profile: ChargingProfile, response_url: str) -> None:
2625        self.charging_profile = charging_profile
2626        self.response_url = response_url
2627
2628    @staticmethod
2629    def from_dict(obj: Any) -> 'SetChargingProfile':
2630        assert isinstance(obj, dict)
2631        charging_profile = ChargingProfile.from_dict(obj.get("charging_profile"))
2632        response_url = from_str(obj.get("response_url"))
2633        return SetChargingProfile(charging_profile, response_url)
2634
2635    def to_dict(self) -> dict:
2636        result: dict = {}
2637        result["charging_profile"] = to_class(ChargingProfile, self.charging_profile)
2638        result["response_url"] = from_str(self.response_url)
2639        return result
2640
2641
2642class StartSession:
2643    authorization_reference: Optional[str]
2644    connector_id: Optional[str]
2645    evse_uid: Optional[str]
2646    location_id: str
2647    response_url: str
2648    token: Token
2649
2650    def __init__(self, authorization_reference: Optional[str], connector_id: Optional[str], evse_uid: Optional[str], location_id: str, response_url: str, token: Token) -> None:
2651        self.authorization_reference = authorization_reference
2652        self.connector_id = connector_id
2653        self.evse_uid = evse_uid
2654        self.location_id = location_id
2655        self.response_url = response_url
2656        self.token = token
2657
2658    @staticmethod
2659    def from_dict(obj: Any) -> 'StartSession':
2660        assert isinstance(obj, dict)
2661        authorization_reference = from_union([from_none, from_str], obj.get("authorization_reference"))
2662        connector_id = from_union([from_none, from_str], obj.get("connector_id"))
2663        evse_uid = from_union([from_none, from_str], obj.get("evse_uid"))
2664        location_id = from_str(obj.get("location_id"))
2665        response_url = from_str(obj.get("response_url"))
2666        token = Token.from_dict(obj.get("token"))
2667        return StartSession(authorization_reference, connector_id, evse_uid, location_id, response_url, token)
2668
2669    def to_dict(self) -> dict:
2670        result: dict = {}
2671        if self.authorization_reference is not None:
2672            result["authorization_reference"] = from_union([from_none, from_str], self.authorization_reference)
2673        if self.connector_id is not None:
2674            result["connector_id"] = from_union([from_none, from_str], self.connector_id)
2675        if self.evse_uid is not None:
2676            result["evse_uid"] = from_union([from_none, from_str], self.evse_uid)
2677        result["location_id"] = from_str(self.location_id)
2678        result["response_url"] = from_str(self.response_url)
2679        result["token"] = to_class(Token, self.token)
2680        return result
2681
2682
2683class StopSession:
2684    response_url: str
2685    session_id: str
2686
2687    def __init__(self, response_url: str, session_id: str) -> None:
2688        self.response_url = response_url
2689        self.session_id = session_id
2690
2691    @staticmethod
2692    def from_dict(obj: Any) -> 'StopSession':
2693        assert isinstance(obj, dict)
2694        response_url = from_str(obj.get("response_url"))
2695        session_id = from_str(obj.get("session_id"))
2696        return StopSession(response_url, session_id)
2697
2698    def to_dict(self) -> dict:
2699        result: dict = {}
2700        result["response_url"] = from_str(self.response_url)
2701        result["session_id"] = from_str(self.session_id)
2702        return result
2703
2704
2705class InvoiceCreator(Enum):
2706    CPO = "CPO"
2707    PTP = "PTP"
2708
2709
2710class Terminal:
2711    address: Optional[str]
2712    city: Optional[str]
2713    coordinates: Optional[GeoLocation]
2714    country: Optional[str]
2715    country_code: Optional[str]
2716    customer_reference: Optional[str]
2717    evse_uids: Optional[List[str]]
2718    invoice_base_url: Optional[str]
2719    invoice_creator: Optional[InvoiceCreator]
2720    last_updated: str
2721    location_ids: Optional[List[str]]
2722    party_id: Optional[str]
2723    postal_code: Optional[str]
2724    reference: Optional[str]
2725    state: Optional[str]
2726    terminal_id: str
2727
2728    def __init__(self, address: Optional[str], city: Optional[str], coordinates: Optional[GeoLocation], country: Optional[str], country_code: Optional[str], customer_reference: Optional[str], evse_uids: Optional[List[str]], invoice_base_url: Optional[str], invoice_creator: Optional[InvoiceCreator], last_updated: str, location_ids: Optional[List[str]], party_id: Optional[str], postal_code: Optional[str], reference: Optional[str], state: Optional[str], terminal_id: str) -> None:
2729        self.address = address
2730        self.city = city
2731        self.coordinates = coordinates
2732        self.country = country
2733        self.country_code = country_code
2734        self.customer_reference = customer_reference
2735        self.evse_uids = evse_uids
2736        self.invoice_base_url = invoice_base_url
2737        self.invoice_creator = invoice_creator
2738        self.last_updated = last_updated
2739        self.location_ids = location_ids
2740        self.party_id = party_id
2741        self.postal_code = postal_code
2742        self.reference = reference
2743        self.state = state
2744        self.terminal_id = terminal_id
2745
2746    @staticmethod
2747    def from_dict(obj: Any) -> 'Terminal':
2748        assert isinstance(obj, dict)
2749        address = from_union([from_none, from_str], obj.get("address"))
2750        city = from_union([from_none, from_str], obj.get("city"))
2751        coordinates = from_union([from_none, GeoLocation.from_dict], obj.get("coordinates"))
2752        country = from_union([from_none, from_str], obj.get("country"))
2753        country_code = from_union([from_none, from_str], obj.get("country_code"))
2754        customer_reference = from_union([from_none, from_str], obj.get("customer_reference"))
2755        evse_uids = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("evse_uids"))
2756        invoice_base_url = from_union([from_none, from_str], obj.get("invoice_base_url"))
2757        invoice_creator = from_union([from_none, InvoiceCreator], obj.get("invoice_creator"))
2758        last_updated = from_str(obj.get("last_updated"))
2759        location_ids = from_union([from_none, lambda x: from_list(from_str, x)], obj.get("location_ids"))
2760        party_id = from_union([from_none, from_str], obj.get("party_id"))
2761        postal_code = from_union([from_none, from_str], obj.get("postal_code"))
2762        reference = from_union([from_none, from_str], obj.get("reference"))
2763        state = from_union([from_none, from_str], obj.get("state"))
2764        terminal_id = from_str(obj.get("terminal_id"))
2765        return Terminal(address, city, coordinates, country, country_code, customer_reference, evse_uids, invoice_base_url, invoice_creator, last_updated, location_ids, party_id, postal_code, reference, state, terminal_id)
2766
2767    def to_dict(self) -> dict:
2768        result: dict = {}
2769        if self.address is not None:
2770            result["address"] = from_union([from_none, from_str], self.address)
2771        if self.city is not None:
2772            result["city"] = from_union([from_none, from_str], self.city)
2773        if self.coordinates is not None:
2774            result["coordinates"] = from_union([from_none, lambda x: to_class(GeoLocation, x)], self.coordinates)
2775        if self.country is not None:
2776            result["country"] = from_union([from_none, from_str], self.country)
2777        if self.country_code is not None:
2778            result["country_code"] = from_union([from_none, from_str], self.country_code)
2779        if self.customer_reference is not None:
2780            result["customer_reference"] = from_union([from_none, from_str], self.customer_reference)
2781        if self.evse_uids is not None:
2782            result["evse_uids"] = from_union([from_none, lambda x: from_list(from_str, x)], self.evse_uids)
2783        if self.invoice_base_url is not None:
2784            result["invoice_base_url"] = from_union([from_none, from_str], self.invoice_base_url)
2785        if self.invoice_creator is not None:
2786            result["invoice_creator"] = from_union([from_none, lambda x: to_enum(InvoiceCreator, x)], self.invoice_creator)
2787        result["last_updated"] = from_str(self.last_updated)
2788        if self.location_ids is not None:
2789            result["location_ids"] = from_union([from_none, lambda x: from_list(from_str, x)], self.location_ids)
2790        if self.party_id is not None:
2791            result["party_id"] = from_union([from_none, from_str], self.party_id)
2792        if self.postal_code is not None:
2793            result["postal_code"] = from_union([from_none, from_str], self.postal_code)
2794        if self.reference is not None:
2795            result["reference"] = from_union([from_none, from_str], self.reference)
2796        if self.state is not None:
2797            result["state"] = from_union([from_none, from_str], self.state)
2798        result["terminal_id"] = from_str(self.terminal_id)
2799        return result
2800
2801
2802class UnlockConnector:
2803    connector_id: str
2804    evse_uid: str
2805    location_id: str
2806    response_url: str
2807
2808    def __init__(self, connector_id: str, evse_uid: str, location_id: str, response_url: str) -> None:
2809        self.connector_id = connector_id
2810        self.evse_uid = evse_uid
2811        self.location_id = location_id
2812        self.response_url = response_url
2813
2814    @staticmethod
2815    def from_dict(obj: Any) -> 'UnlockConnector':
2816        assert isinstance(obj, dict)
2817        connector_id = from_str(obj.get("connector_id"))
2818        evse_uid = from_str(obj.get("evse_uid"))
2819        location_id = from_str(obj.get("location_id"))
2820        response_url = from_str(obj.get("response_url"))
2821        return UnlockConnector(connector_id, evse_uid, location_id, response_url)
2822
2823    def to_dict(self) -> dict:
2824        result: dict = {}
2825        result["connector_id"] = from_str(self.connector_id)
2826        result["evse_uid"] = from_str(self.evse_uid)
2827        result["location_id"] = from_str(self.location_id)
2828        result["response_url"] = from_str(self.response_url)
2829        return result
2830
2831
2832class VersionNumber(Enum):
2833    THE_20 = "2.0"
2834    THE_21 = "2.1"
2835    THE_211 = "2.1.1"
2836    THE_22 = "2.2"
2837    THE_221 = "2.2.1"
2838    THE_230 = "2.3.0"
2839
2840
2841class Version:
2842    url: str
2843    version: VersionNumber
2844
2845    def __init__(self, url: str, version: VersionNumber) -> None:
2846        self.url = url
2847        self.version = version
2848
2849    @staticmethod
2850    def from_dict(obj: Any) -> 'Version':
2851        assert isinstance(obj, dict)
2852        url = from_str(obj.get("url"))
2853        version = VersionNumber(obj.get("version"))
2854        return Version(url, version)
2855
2856    def to_dict(self) -> dict:
2857        result: dict = {}
2858        result["url"] = from_str(self.url)
2859        result["version"] = to_enum(VersionNumber, self.version)
2860        return result
2861
2862
2863class VersionDetails:
2864    endpoints: List[Endpoint]
2865    version: VersionNumber
2866
2867    def __init__(self, endpoints: List[Endpoint], version: VersionNumber) -> None:
2868        self.endpoints = endpoints
2869        self.version = version
2870
2871    @staticmethod
2872    def from_dict(obj: Any) -> 'VersionDetails':
2873        assert isinstance(obj, dict)
2874        endpoints = from_list(Endpoint.from_dict, obj.get("endpoints"))
2875        version = VersionNumber(obj.get("version"))
2876        return VersionDetails(endpoints, version)
2877
2878    def to_dict(self) -> dict:
2879        result: dict = {}
2880        result["endpoints"] = from_list(lambda x: to_class(Endpoint, x), self.endpoints)
2881        result["version"] = to_enum(VersionNumber, self.version)
2882        return result
2883
2884
2885class V230Payments:
2886    active_charging_profile: Optional[ActiveChargingProfile]
2887    active_charging_profile_result: Optional[ActiveChargingProfileResult]
2888    authorization_info: Optional[AuthorizationInfo]
2889    cancel_reservation: Optional[CancelReservation]
2890    cdr: Optional[Cdr]
2891    charging_preferences: Optional[ChargingPreferences]
2892    charging_profile: Optional[ChargingProfile]
2893    charging_profile_response: Optional[ChargingProfileResponse]
2894    charging_profile_result: Optional[ChargingProfileResult]
2895    clear_profile_result: Optional[ClearProfileResult]
2896    command_response: Optional[CommandResponse]
2897    command_result: Optional[CommandResult]
2898    connector: Optional[Connector]
2899    credentials: Optional[Credentials]
2900    endpoint: Optional[Endpoint]
2901    evse: Optional[Evse]
2902    financial_advice_confirmation: Optional[FinancialAdviceConfirmation]
2903    hub_client_info: Optional[HubClientInfo]
2904    location: Optional[Location]
2905    location_references: Optional[LocationReferences]
2906    reserve_now: Optional[ReserveNow]
2907    session: Optional[Session]
2908    set_charging_profile: Optional[SetChargingProfile]
2909    start_session: Optional[StartSession]
2910    stop_session: Optional[StopSession]
2911    tariff: Optional[Tariff]
2912    terminal: Optional[Terminal]
2913    token: Optional[Token]
2914    unlock_connector: Optional[UnlockConnector]
2915    version: Optional[Version]
2916    version_details: Optional[VersionDetails]
2917
2918    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], financial_advice_confirmation: Optional[FinancialAdviceConfirmation], 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], terminal: Optional[Terminal], token: Optional[Token], unlock_connector: Optional[UnlockConnector], version: Optional[Version], version_details: Optional[VersionDetails]) -> None:
2919        self.active_charging_profile = active_charging_profile
2920        self.active_charging_profile_result = active_charging_profile_result
2921        self.authorization_info = authorization_info
2922        self.cancel_reservation = cancel_reservation
2923        self.cdr = cdr
2924        self.charging_preferences = charging_preferences
2925        self.charging_profile = charging_profile
2926        self.charging_profile_response = charging_profile_response
2927        self.charging_profile_result = charging_profile_result
2928        self.clear_profile_result = clear_profile_result
2929        self.command_response = command_response
2930        self.command_result = command_result
2931        self.connector = connector
2932        self.credentials = credentials
2933        self.endpoint = endpoint
2934        self.evse = evse
2935        self.financial_advice_confirmation = financial_advice_confirmation
2936        self.hub_client_info = hub_client_info
2937        self.location = location
2938        self.location_references = location_references
2939        self.reserve_now = reserve_now
2940        self.session = session
2941        self.set_charging_profile = set_charging_profile
2942        self.start_session = start_session
2943        self.stop_session = stop_session
2944        self.tariff = tariff
2945        self.terminal = terminal
2946        self.token = token
2947        self.unlock_connector = unlock_connector
2948        self.version = version
2949        self.version_details = version_details
2950
2951    @staticmethod
2952    def from_dict(obj: Any) -> 'V230Payments':
2953        assert isinstance(obj, dict)
2954        active_charging_profile = from_union([ActiveChargingProfile.from_dict, from_none], obj.get("active_charging_profile"))
2955        active_charging_profile_result = from_union([ActiveChargingProfileResult.from_dict, from_none], obj.get("active_charging_profile_result"))
2956        authorization_info = from_union([AuthorizationInfo.from_dict, from_none], obj.get("authorization_info"))
2957        cancel_reservation = from_union([CancelReservation.from_dict, from_none], obj.get("cancel_reservation"))
2958        cdr = from_union([Cdr.from_dict, from_none], obj.get("cdr"))
2959        charging_preferences = from_union([ChargingPreferences.from_dict, from_none], obj.get("charging_preferences"))
2960        charging_profile = from_union([ChargingProfile.from_dict, from_none], obj.get("charging_profile"))
2961        charging_profile_response = from_union([ChargingProfileResponse.from_dict, from_none], obj.get("charging_profile_response"))
2962        charging_profile_result = from_union([ChargingProfileResult.from_dict, from_none], obj.get("charging_profile_result"))
2963        clear_profile_result = from_union([ClearProfileResult.from_dict, from_none], obj.get("clear_profile_result"))
2964        command_response = from_union([CommandResponse.from_dict, from_none], obj.get("command_response"))
2965        command_result = from_union([CommandResult.from_dict, from_none], obj.get("command_result"))
2966        connector = from_union([Connector.from_dict, from_none], obj.get("connector"))
2967        credentials = from_union([Credentials.from_dict, from_none], obj.get("credentials"))
2968        endpoint = from_union([Endpoint.from_dict, from_none], obj.get("endpoint"))
2969        evse = from_union([Evse.from_dict, from_none], obj.get("evse"))
2970        financial_advice_confirmation = from_union([FinancialAdviceConfirmation.from_dict, from_none], obj.get("financial_advice_confirmation"))
2971        hub_client_info = from_union([HubClientInfo.from_dict, from_none], obj.get("hub_client_info"))
2972        location = from_union([Location.from_dict, from_none], obj.get("location"))
2973        location_references = from_union([from_none, LocationReferences.from_dict], obj.get("location_references"))
2974        reserve_now = from_union([ReserveNow.from_dict, from_none], obj.get("reserve_now"))
2975        session = from_union([Session.from_dict, from_none], obj.get("session"))
2976        set_charging_profile = from_union([SetChargingProfile.from_dict, from_none], obj.get("set_charging_profile"))
2977        start_session = from_union([StartSession.from_dict, from_none], obj.get("start_session"))
2978        stop_session = from_union([StopSession.from_dict, from_none], obj.get("stop_session"))
2979        tariff = from_union([Tariff.from_dict, from_none], obj.get("tariff"))
2980        terminal = from_union([Terminal.from_dict, from_none], obj.get("terminal"))
2981        token = from_union([Token.from_dict, from_none], obj.get("token"))
2982        unlock_connector = from_union([UnlockConnector.from_dict, from_none], obj.get("unlock_connector"))
2983        version = from_union([Version.from_dict, from_none], obj.get("version"))
2984        version_details = from_union([VersionDetails.from_dict, from_none], obj.get("version_details"))
2985        return V230Payments(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, financial_advice_confirmation, hub_client_info, location, location_references, reserve_now, session, set_charging_profile, start_session, stop_session, tariff, terminal, token, unlock_connector, version, version_details)
2986
2987    def to_dict(self) -> dict:
2988        result: dict = {}
2989        if self.active_charging_profile is not None:
2990            result["active_charging_profile"] = from_union([lambda x: to_class(ActiveChargingProfile, x), from_none], self.active_charging_profile)
2991        if self.active_charging_profile_result is not None:
2992            result["active_charging_profile_result"] = from_union([lambda x: to_class(ActiveChargingProfileResult, x), from_none], self.active_charging_profile_result)
2993        if self.authorization_info is not None:
2994            result["authorization_info"] = from_union([lambda x: to_class(AuthorizationInfo, x), from_none], self.authorization_info)
2995        if self.cancel_reservation is not None:
2996            result["cancel_reservation"] = from_union([lambda x: to_class(CancelReservation, x), from_none], self.cancel_reservation)
2997        if self.cdr is not None:
2998            result["cdr"] = from_union([lambda x: to_class(Cdr, x), from_none], self.cdr)
2999        if self.charging_preferences is not None:
3000            result["charging_preferences"] = from_union([lambda x: to_class(ChargingPreferences, x), from_none], self.charging_preferences)
3001        if self.charging_profile is not None:
3002            result["charging_profile"] = from_union([lambda x: to_class(ChargingProfile, x), from_none], self.charging_profile)
3003        if self.charging_profile_response is not None:
3004            result["charging_profile_response"] = from_union([lambda x: to_class(ChargingProfileResponse, x), from_none], self.charging_profile_response)
3005        if self.charging_profile_result is not None:
3006            result["charging_profile_result"] = from_union([lambda x: to_class(ChargingProfileResult, x), from_none], self.charging_profile_result)
3007        if self.clear_profile_result is not None:
3008            result["clear_profile_result"] = from_union([lambda x: to_class(ClearProfileResult, x), from_none], self.clear_profile_result)
3009        if self.command_response is not None:
3010            result["command_response"] = from_union([lambda x: to_class(CommandResponse, x), from_none], self.command_response)
3011        if self.command_result is not None:
3012            result["command_result"] = from_union([lambda x: to_class(CommandResult, x), from_none], self.command_result)
3013        if self.connector is not None:
3014            result["connector"] = from_union([lambda x: to_class(Connector, x), from_none], self.connector)
3015        if self.credentials is not None:
3016            result["credentials"] = from_union([lambda x: to_class(Credentials, x), from_none], self.credentials)
3017        if self.endpoint is not None:
3018            result["endpoint"] = from_union([lambda x: to_class(Endpoint, x), from_none], self.endpoint)
3019        if self.evse is not None:
3020            result["evse"] = from_union([lambda x: to_class(Evse, x), from_none], self.evse)
3021        if self.financial_advice_confirmation is not None:
3022            result["financial_advice_confirmation"] = from_union([lambda x: to_class(FinancialAdviceConfirmation, x), from_none], self.financial_advice_confirmation)
3023        if self.hub_client_info is not None:
3024            result["hub_client_info"] = from_union([lambda x: to_class(HubClientInfo, x), from_none], self.hub_client_info)
3025        if self.location is not None:
3026            result["location"] = from_union([lambda x: to_class(Location, x), from_none], self.location)
3027        if self.location_references is not None:
3028            result["location_references"] = from_union([from_none, lambda x: to_class(LocationReferences, x)], self.location_references)
3029        if self.reserve_now is not None:
3030            result["reserve_now"] = from_union([lambda x: to_class(ReserveNow, x), from_none], self.reserve_now)
3031        if self.session is not None:
3032            result["session"] = from_union([lambda x: to_class(Session, x), from_none], self.session)
3033        if self.set_charging_profile is not None:
3034            result["set_charging_profile"] = from_union([lambda x: to_class(SetChargingProfile, x), from_none], self.set_charging_profile)
3035        if self.start_session is not None:
3036            result["start_session"] = from_union([lambda x: to_class(StartSession, x), from_none], self.start_session)
3037        if self.stop_session is not None:
3038            result["stop_session"] = from_union([lambda x: to_class(StopSession, x), from_none], self.stop_session)
3039        if self.tariff is not None:
3040            result["tariff"] = from_union([lambda x: to_class(Tariff, x), from_none], self.tariff)
3041        if self.terminal is not None:
3042            result["terminal"] = from_union([lambda x: to_class(Terminal, x), from_none], self.terminal)
3043        if self.token is not None:
3044            result["token"] = from_union([lambda x: to_class(Token, x), from_none], self.token)
3045        if self.unlock_connector is not None:
3046            result["unlock_connector"] = from_union([lambda x: to_class(UnlockConnector, x), from_none], self.unlock_connector)
3047        if self.version is not None:
3048            result["version"] = from_union([lambda x: to_class(Version, x), from_none], self.version)
3049        if self.version_details is not None:
3050            result["version_details"] = from_union([lambda x: to_class(VersionDetails, x), from_none], self.version_details)
3051        return result
3052
3053
3054def v230_payments_from_dict(s: Any) -> V230Payments:
3055    return V230Payments.from_dict(s)
3056
3057
3058def v230_payments_to_dict(x: V230Payments) -> Any:
3059    return to_class(V230Payments, x)