modules/libjuju/juju/client/_definitions.py

   1 # DO NOT CHANGE THIS FILE! This file is auto-generated by facade.py.
   2 # Changes will be overwritten/lost when the file is regenerated.
   3
   4 from juju.client.facade import ReturnMapping, Type
   5
   6
   7 class APIHostPortsResult(Type):
   8     _toSchema = {'servers': 'servers'}
   9     _toPy = {'servers': 'servers'}
  10     def __init__(self, servers=None, **unknown_fields):
  11         '''
  12         servers : typing.Sequence[~HostPort]
  13         '''
  14         self.servers = [HostPort.from_json(o) for o in servers or []]
  15
  16
  17
  18 class Action(Type):
  19     _toSchema = {'name': 'name', 'parameters': 'parameters', 'receiver': 'receiver', 'tag': 'tag'}
  20     _toPy = {'name': 'name', 'parameters': 'parameters', 'receiver': 'receiver', 'tag': 'tag'}
  21     def __init__(self, name=None, parameters=None, receiver=None, tag=None, **unknown_fields):
  22         '''
  23         name : str
  24         parameters : typing.Mapping[str, typing.Any]
  25         receiver : str
  26         tag : str
  27         '''
  28         self.name = name
  29         self.parameters = parameters
  30         self.receiver = receiver
  31         self.tag = tag
  32
  33
  34
  35 class ActionExecutionResult(Type):
  36     _toSchema = {'action_tag': 'action-tag', 'message': 'message', 'results': 'results', 'status': 'status'}
  37     _toPy = {'action-tag': 'action_tag', 'message': 'message', 'results': 'results', 'status': 'status'}
  38     def __init__(self, action_tag=None, message=None, results=None, status=None, **unknown_fields):
  39         '''
  40         action_tag : str
  41         message : str
  42         results : typing.Mapping[str, typing.Any]
  43         status : str
  44         '''
  45         self.action_tag = action_tag
  46         self.message = message
  47         self.results = results
  48         self.status = status
  49
  50
  51
  52 class ActionExecutionResults(Type):
  53     _toSchema = {'results': 'results'}
  54     _toPy = {'results': 'results'}
  55     def __init__(self, results=None, **unknown_fields):
  56         '''
  57         results : typing.Sequence[~ActionExecutionResult]
  58         '''
  59         self.results = [ActionExecutionResult.from_json(o) for o in results or []]
  60
  61
  62
  63 class ActionPruneArgs(Type):
  64     _toSchema = {'max_history_mb': 'max-history-mb', 'max_history_time': 'max-history-time'}
  65     _toPy = {'max-history-mb': 'max_history_mb', 'max-history-time': 'max_history_time'}
  66     def __init__(self, max_history_mb=None, max_history_time=None, **unknown_fields):
  67         '''
  68         max_history_mb : int
  69         max_history_time : int
  70         '''
  71         self.max_history_mb = max_history_mb
  72         self.max_history_time = max_history_time
  73
  74
  75
  76 class ActionResult(Type):
  77     _toSchema = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
  78     _toPy = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
  79     def __init__(self, action=None, completed=None, enqueued=None, error=None, message=None, output=None, started=None, status=None, **unknown_fields):
  80         '''
  81         action : Action
  82         completed : str
  83         enqueued : str
  84         error : Error
  85         message : str
  86         output : typing.Mapping[str, typing.Any]
  87         started : str
  88         status : str
  89         '''
  90         self.action = Action.from_json(action) if action else None
  91         self.completed = completed
  92         self.enqueued = enqueued
  93         self.error = Error.from_json(error) if error else None
  94         self.message = message
  95         self.output = output
  96         self.started = started
  97         self.status = status
  98
  99
 100
 101 class ActionResults(Type):
 102     _toSchema = {'results': 'results'}
 103     _toPy = {'results': 'results'}
 104     def __init__(self, results=None, **unknown_fields):
 105         '''
 106         results : typing.Sequence[~ActionResult]
 107         '''
 108         self.results = [ActionResult.from_json(o) for o in results or []]
 109
 110
 111
 112 class ActionSpec(Type):
 113     _toSchema = {'description': 'description', 'params': 'params'}
 114     _toPy = {'description': 'description', 'params': 'params'}
 115     def __init__(self, description=None, params=None, **unknown_fields):
 116         '''
 117         description : str
 118         params : typing.Mapping[str, typing.Any]
 119         '''
 120         self.description = description
 121         self.params = params
 122
 123
 124
 125 class Actions(Type):
 126     _toSchema = {'actions': 'actions'}
 127     _toPy = {'actions': 'actions'}
 128     def __init__(self, actions=None, **unknown_fields):
 129         '''
 130         actions : typing.Sequence[~Action]
 131         '''
 132         self.actions = [Action.from_json(o) for o in actions or []]
 133
 134
 135
 136 class ActionsByName(Type):
 137     _toSchema = {'actions': 'actions', 'error': 'error', 'name': 'name'}
 138     _toPy = {'actions': 'actions', 'error': 'error', 'name': 'name'}
 139     def __init__(self, actions=None, error=None, name=None, **unknown_fields):
 140         '''
 141         actions : typing.Sequence[~ActionResult]
 142         error : Error
 143         name : str
 144         '''
 145         self.actions = [ActionResult.from_json(o) for o in actions or []]
 146         self.error = Error.from_json(error) if error else None
 147         self.name = name
 148
 149
 150
 151 class ActionsByNames(Type):
 152     _toSchema = {'actions': 'actions'}
 153     _toPy = {'actions': 'actions'}
 154     def __init__(self, actions=None, **unknown_fields):
 155         '''
 156         actions : typing.Sequence[~ActionsByName]
 157         '''
 158         self.actions = [ActionsByName.from_json(o) for o in actions or []]
 159
 160
 161
 162 class ActionsByReceiver(Type):
 163     _toSchema = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
 164     _toPy = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
 165     def __init__(self, actions=None, error=None, receiver=None, **unknown_fields):
 166         '''
 167         actions : typing.Sequence[~ActionResult]
 168         error : Error
 169         receiver : str
 170         '''
 171         self.actions = [ActionResult.from_json(o) for o in actions or []]
 172         self.error = Error.from_json(error) if error else None
 173         self.receiver = receiver
 174
 175
 176
 177 class ActionsByReceivers(Type):
 178     _toSchema = {'actions': 'actions'}
 179     _toPy = {'actions': 'actions'}
 180     def __init__(self, actions=None, **unknown_fields):
 181         '''
 182         actions : typing.Sequence[~ActionsByReceiver]
 183         '''
 184         self.actions = [ActionsByReceiver.from_json(o) for o in actions or []]
 185
 186
 187
 188 class AddApplicationOffer(Type):
 189     _toSchema = {'application_description': 'application-description', 'application_name': 'application-name', 'endpoints': 'endpoints', 'model_tag': 'model-tag', 'offer_name': 'offer-name'}
 190     _toPy = {'application-description': 'application_description', 'application-name': 'application_name', 'endpoints': 'endpoints', 'model-tag': 'model_tag', 'offer-name': 'offer_name'}
 191     def __init__(self, application_description=None, application_name=None, endpoints=None, model_tag=None, offer_name=None, **unknown_fields):
 192         '''
 193         application_description : str
 194         application_name : str
 195         endpoints : typing.Mapping[str, str]
 196         model_tag : str
 197         offer_name : str
 198         '''
 199         self.application_description = application_description
 200         self.application_name = application_name
 201         self.endpoints = endpoints
 202         self.model_tag = model_tag
 203         self.offer_name = offer_name
 204
 205
 206
 207 class AddApplicationOffers(Type):
 208     _toSchema = {'offers': 'Offers'}
 209     _toPy = {'Offers': 'offers'}
 210     def __init__(self, offers=None, **unknown_fields):
 211         '''
 212         offers : typing.Sequence[~AddApplicationOffer]
 213         '''
 214         self.offers = [AddApplicationOffer.from_json(o) for o in offers or []]
 215
 216
 217
 218 class AddApplicationUnits(Type):
 219     _toSchema = {'application': 'application', 'num_units': 'num-units', 'placement': 'placement'}
 220     _toPy = {'application': 'application', 'num-units': 'num_units', 'placement': 'placement'}
 221     def __init__(self, application=None, num_units=None, placement=None, **unknown_fields):
 222         '''
 223         application : str
 224         num_units : int
 225         placement : typing.Sequence[~Placement]
 226         '''
 227         self.application = application
 228         self.num_units = num_units
 229         self.placement = [Placement.from_json(o) for o in placement or []]
 230
 231
 232
 233 class AddApplicationUnitsResults(Type):
 234     _toSchema = {'units': 'units'}
 235     _toPy = {'units': 'units'}
 236     def __init__(self, units=None, **unknown_fields):
 237         '''
 238         units : typing.Sequence[str]
 239         '''
 240         self.units = units
 241
 242
 243
 244 class AddCharm(Type):
 245     _toSchema = {'channel': 'channel', 'url': 'url'}
 246     _toPy = {'channel': 'channel', 'url': 'url'}
 247     def __init__(self, channel=None, url=None, **unknown_fields):
 248         '''
 249         channel : str
 250         url : str
 251         '''
 252         self.channel = channel
 253         self.url = url
 254
 255
 256
 257 class AddCharmWithAuthorization(Type):
 258     _toSchema = {'channel': 'channel', 'macaroon': 'macaroon', 'url': 'url'}
 259     _toPy = {'channel': 'channel', 'macaroon': 'macaroon', 'url': 'url'}
 260     def __init__(self, channel=None, macaroon=None, url=None, **unknown_fields):
 261         '''
 262         channel : str
 263         macaroon : Macaroon
 264         url : str
 265         '''
 266         self.channel = channel
 267         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
 268         self.url = url
 269
 270
 271
 272 class AddCloudArgs(Type):
 273     _toSchema = {'cloud': 'cloud', 'name': 'name'}
 274     _toPy = {'cloud': 'cloud', 'name': 'name'}
 275     def __init__(self, cloud=None, name=None, **unknown_fields):
 276         '''
 277         cloud : Cloud
 278         name : str
 279         '''
 280         self.cloud = Cloud.from_json(cloud) if cloud else None
 281         self.name = name
 282
 283
 284
 285 class AddMachineParams(Type):
 286     _toSchema = {'addresses': 'addresses', 'constraints': 'constraints', 'container_type': 'container-type', 'disks': 'disks', 'hardware_characteristics': 'hardware-characteristics', 'instance_id': 'instance-id', 'jobs': 'jobs', 'nonce': 'nonce', 'parent_id': 'parent-id', 'placement': 'placement', 'series': 'series'}
 287     _toPy = {'addresses': 'addresses', 'constraints': 'constraints', 'container-type': 'container_type', 'disks': 'disks', 'hardware-characteristics': 'hardware_characteristics', 'instance-id': 'instance_id', 'jobs': 'jobs', 'nonce': 'nonce', 'parent-id': 'parent_id', 'placement': 'placement', 'series': 'series'}
 288     def __init__(self, addresses=None, constraints=None, container_type=None, disks=None, hardware_characteristics=None, instance_id=None, jobs=None, nonce=None, parent_id=None, placement=None, series=None, **unknown_fields):
 289         '''
 290         addresses : typing.Sequence[~Address]
 291         constraints : Value
 292         container_type : str
 293         disks : typing.Sequence[~Constraints]
 294         hardware_characteristics : HardwareCharacteristics
 295         instance_id : str
 296         jobs : typing.Sequence[str]
 297         nonce : str
 298         parent_id : str
 299         placement : Placement
 300         series : str
 301         '''
 302         self.addresses = [Address.from_json(o) for o in addresses or []]
 303         self.constraints = Value.from_json(constraints) if constraints else None
 304         self.container_type = container_type
 305         self.disks = [Constraints.from_json(o) for o in disks or []]
 306         self.hardware_characteristics = HardwareCharacteristics.from_json(hardware_characteristics) if hardware_characteristics else None
 307         self.instance_id = instance_id
 308         self.jobs = jobs
 309         self.nonce = nonce
 310         self.parent_id = parent_id
 311         self.placement = Placement.from_json(placement) if placement else None
 312         self.series = series
 313
 314
 315
 316 class AddMachines(Type):
 317     _toSchema = {'params': 'params'}
 318     _toPy = {'params': 'params'}
 319     def __init__(self, params=None, **unknown_fields):
 320         '''
 321         params : typing.Sequence[~AddMachineParams]
 322         '''
 323         self.params = [AddMachineParams.from_json(o) for o in params or []]
 324
 325
 326
 327 class AddMachinesResult(Type):
 328     _toSchema = {'error': 'error', 'machine': 'machine'}
 329     _toPy = {'error': 'error', 'machine': 'machine'}
 330     def __init__(self, error=None, machine=None, **unknown_fields):
 331         '''
 332         error : Error
 333         machine : str
 334         '''
 335         self.error = Error.from_json(error) if error else None
 336         self.machine = machine
 337
 338
 339
 340 class AddMachinesResults(Type):
 341     _toSchema = {'machines': 'machines'}
 342     _toPy = {'machines': 'machines'}
 343     def __init__(self, machines=None, **unknown_fields):
 344         '''
 345         machines : typing.Sequence[~AddMachinesResult]
 346         '''
 347         self.machines = [AddMachinesResult.from_json(o) for o in machines or []]
 348
 349
 350
 351 class AddPendingResourcesArgs(Type):
 352     _toSchema = {'addcharmwithauthorization': 'AddCharmWithAuthorization', 'entity': 'Entity', 'resources': 'Resources'}
 353     _toPy = {'AddCharmWithAuthorization': 'addcharmwithauthorization', 'Entity': 'entity', 'Resources': 'resources'}
 354     def __init__(self, addcharmwithauthorization=None, entity=None, resources=None, **unknown_fields):
 355         '''
 356         addcharmwithauthorization : AddCharmWithAuthorization
 357         entity : Entity
 358         resources : typing.Sequence[~CharmResource]
 359         '''
 360         self.addcharmwithauthorization = AddCharmWithAuthorization.from_json(addcharmwithauthorization) if addcharmwithauthorization else None
 361         self.entity = Entity.from_json(entity) if entity else None
 362         self.resources = [CharmResource.from_json(o) for o in resources or []]
 363
 364
 365
 366 class AddPendingResourcesResult(Type):
 367     _toSchema = {'errorresult': 'ErrorResult', 'pending_ids': 'pending-ids'}
 368     _toPy = {'ErrorResult': 'errorresult', 'pending-ids': 'pending_ids'}
 369     def __init__(self, errorresult=None, pending_ids=None, **unknown_fields):
 370         '''
 371         errorresult : ErrorResult
 372         pending_ids : typing.Sequence[str]
 373         '''
 374         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
 375         self.pending_ids = pending_ids
 376
 377
 378
 379 class AddRelation(Type):
 380     _toSchema = {'endpoints': 'endpoints'}
 381     _toPy = {'endpoints': 'endpoints'}
 382     def __init__(self, endpoints=None, **unknown_fields):
 383         '''
 384         endpoints : typing.Sequence[str]
 385         '''
 386         self.endpoints = endpoints
 387
 388
 389
 390 class AddRelationResults(Type):
 391     _toSchema = {'endpoints': 'endpoints'}
 392     _toPy = {'endpoints': 'endpoints'}
 393     def __init__(self, endpoints=None, **unknown_fields):
 394         '''
 395         endpoints : typing.Mapping[str, ~CharmRelation]
 396         '''
 397         self.endpoints = endpoints
 398
 399
 400
 401 class AddStorageDetails(Type):
 402     _toSchema = {'storage_tags': 'storage-tags'}
 403     _toPy = {'storage-tags': 'storage_tags'}
 404     def __init__(self, storage_tags=None, **unknown_fields):
 405         '''
 406         storage_tags : typing.Sequence[str]
 407         '''
 408         self.storage_tags = storage_tags
 409
 410
 411
 412 class AddStorageResult(Type):
 413     _toSchema = {'error': 'error', 'result': 'result'}
 414     _toPy = {'error': 'error', 'result': 'result'}
 415     def __init__(self, error=None, result=None, **unknown_fields):
 416         '''
 417         error : Error
 418         result : AddStorageDetails
 419         '''
 420         self.error = Error.from_json(error) if error else None
 421         self.result = AddStorageDetails.from_json(result) if result else None
 422
 423
 424
 425 class AddStorageResults(Type):
 426     _toSchema = {'results': 'results'}
 427     _toPy = {'results': 'results'}
 428     def __init__(self, results=None, **unknown_fields):
 429         '''
 430         results : typing.Sequence[~AddStorageResult]
 431         '''
 432         self.results = [AddStorageResult.from_json(o) for o in results or []]
 433
 434
 435
 436 class AddSubnetParams(Type):
 437     _toSchema = {'space_tag': 'space-tag', 'subnet_provider_id': 'subnet-provider-id', 'subnet_tag': 'subnet-tag', 'zones': 'zones'}
 438     _toPy = {'space-tag': 'space_tag', 'subnet-provider-id': 'subnet_provider_id', 'subnet-tag': 'subnet_tag', 'zones': 'zones'}
 439     def __init__(self, space_tag=None, subnet_provider_id=None, subnet_tag=None, zones=None, **unknown_fields):
 440         '''
 441         space_tag : str
 442         subnet_provider_id : str
 443         subnet_tag : str
 444         zones : typing.Sequence[str]
 445         '''
 446         self.space_tag = space_tag
 447         self.subnet_provider_id = subnet_provider_id
 448         self.subnet_tag = subnet_tag
 449         self.zones = zones
 450
 451
 452
 453 class AddSubnetsParams(Type):
 454     _toSchema = {'subnets': 'subnets'}
 455     _toPy = {'subnets': 'subnets'}
 456     def __init__(self, subnets=None, **unknown_fields):
 457         '''
 458         subnets : typing.Sequence[~AddSubnetParams]
 459         '''
 460         self.subnets = [AddSubnetParams.from_json(o) for o in subnets or []]
 461
 462
 463
 464 class AddUser(Type):
 465     _toSchema = {'display_name': 'display-name', 'password': 'password', 'username': 'username'}
 466     _toPy = {'display-name': 'display_name', 'password': 'password', 'username': 'username'}
 467     def __init__(self, display_name=None, password=None, username=None, **unknown_fields):
 468         '''
 469         display_name : str
 470         password : str
 471         username : str
 472         '''
 473         self.display_name = display_name
 474         self.password = password
 475         self.username = username
 476
 477
 478
 479 class AddUserResult(Type):
 480     _toSchema = {'error': 'error', 'secret_key': 'secret-key', 'tag': 'tag'}
 481     _toPy = {'error': 'error', 'secret-key': 'secret_key', 'tag': 'tag'}
 482     def __init__(self, error=None, secret_key=None, tag=None, **unknown_fields):
 483         '''
 484         error : Error
 485         secret_key : typing.Sequence[int]
 486         tag : str
 487         '''
 488         self.error = Error.from_json(error) if error else None
 489         self.secret_key = secret_key
 490         self.tag = tag
 491
 492
 493
 494 class AddUserResults(Type):
 495     _toSchema = {'results': 'results'}
 496     _toPy = {'results': 'results'}
 497     def __init__(self, results=None, **unknown_fields):
 498         '''
 499         results : typing.Sequence[~AddUserResult]
 500         '''
 501         self.results = [AddUserResult.from_json(o) for o in results or []]
 502
 503
 504
 505 class AddUsers(Type):
 506     _toSchema = {'users': 'users'}
 507     _toPy = {'users': 'users'}
 508     def __init__(self, users=None, **unknown_fields):
 509         '''
 510         users : typing.Sequence[~AddUser]
 511         '''
 512         self.users = [AddUser.from_json(o) for o in users or []]
 513
 514
 515
 516 class Address(Type):
 517     _toSchema = {'scope': 'scope', 'space_name': 'space-name', 'type_': 'type', 'value': 'value'}
 518     _toPy = {'scope': 'scope', 'space-name': 'space_name', 'type': 'type_', 'value': 'value'}
 519     def __init__(self, scope=None, space_name=None, type_=None, value=None, **unknown_fields):
 520         '''
 521         scope : str
 522         space_name : str
 523         type_ : str
 524         value : str
 525         '''
 526         self.scope = scope
 527         self.space_name = space_name
 528         self.type_ = type_
 529         self.value = value
 530
 531
 532
 533 class AdoptResourcesArgs(Type):
 534     _toSchema = {'model_tag': 'model-tag', 'source_controller_version': 'source-controller-version'}
 535     _toPy = {'model-tag': 'model_tag', 'source-controller-version': 'source_controller_version'}
 536     def __init__(self, model_tag=None, source_controller_version=None, **unknown_fields):
 537         '''
 538         model_tag : str
 539         source_controller_version : Number
 540         '''
 541         self.model_tag = model_tag
 542         self.source_controller_version = Number.from_json(source_controller_version) if source_controller_version else None
 543
 544
 545
 546 class AgentGetEntitiesResult(Type):
 547     _toSchema = {'container_type': 'container-type', 'error': 'error', 'jobs': 'jobs', 'life': 'life'}
 548     _toPy = {'container-type': 'container_type', 'error': 'error', 'jobs': 'jobs', 'life': 'life'}
 549     def __init__(self, container_type=None, error=None, jobs=None, life=None, **unknown_fields):
 550         '''
 551         container_type : str
 552         error : Error
 553         jobs : typing.Sequence[str]
 554         life : str
 555         '''
 556         self.container_type = container_type
 557         self.error = Error.from_json(error) if error else None
 558         self.jobs = jobs
 559         self.life = life
 560
 561
 562
 563 class AgentGetEntitiesResults(Type):
 564     _toSchema = {'entities': 'entities'}
 565     _toPy = {'entities': 'entities'}
 566     def __init__(self, entities=None, **unknown_fields):
 567         '''
 568         entities : typing.Sequence[~AgentGetEntitiesResult]
 569         '''
 570         self.entities = [AgentGetEntitiesResult.from_json(o) for o in entities or []]
 571
 572
 573
 574 class AgentVersionResult(Type):
 575     _toSchema = {'version': 'version'}
 576     _toPy = {'version': 'version'}
 577     def __init__(self, version=None, **unknown_fields):
 578         '''
 579         version : Number
 580         '''
 581         self.version = Number.from_json(version) if version else None
 582
 583
 584
 585 class AllWatcherId(Type):
 586     _toSchema = {'watcher_id': 'watcher-id'}
 587     _toPy = {'watcher-id': 'watcher_id'}
 588     def __init__(self, watcher_id=None, **unknown_fields):
 589         '''
 590         watcher_id : str
 591         '''
 592         self.watcher_id = watcher_id
 593
 594
 595
 596 class AllWatcherNextResults(Type):
 597     _toSchema = {'deltas': 'deltas'}
 598     _toPy = {'deltas': 'deltas'}
 599     def __init__(self, deltas=None, **unknown_fields):
 600         '''
 601         deltas : typing.Sequence[~Delta]
 602         '''
 603         self.deltas = [Delta.from_json(o) for o in deltas or []]
 604
 605
 606
 607 class AnnotationsGetResult(Type):
 608     _toSchema = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
 609     _toPy = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
 610     def __init__(self, annotations=None, entity=None, error=None, **unknown_fields):
 611         '''
 612         annotations : typing.Mapping[str, str]
 613         entity : str
 614         error : ErrorResult
 615         '''
 616         self.annotations = annotations
 617         self.entity = entity
 618         self.error = ErrorResult.from_json(error) if error else None
 619
 620
 621
 622 class AnnotationsGetResults(Type):
 623     _toSchema = {'results': 'results'}
 624     _toPy = {'results': 'results'}
 625     def __init__(self, results=None, **unknown_fields):
 626         '''
 627         results : typing.Sequence[~AnnotationsGetResult]
 628         '''
 629         self.results = [AnnotationsGetResult.from_json(o) for o in results or []]
 630
 631
 632
 633 class AnnotationsSet(Type):
 634     _toSchema = {'annotations': 'annotations'}
 635     _toPy = {'annotations': 'annotations'}
 636     def __init__(self, annotations=None, **unknown_fields):
 637         '''
 638         annotations : typing.Sequence[~EntityAnnotations]
 639         '''
 640         self.annotations = [EntityAnnotations.from_json(o) for o in annotations or []]
 641
 642
 643
 644 class ApplicationCharm(Type):
 645     _toSchema = {'charm_modified_version': 'charm-modified-version', 'force_upgrade': 'force-upgrade', 'sha256': 'sha256', 'url': 'url'}
 646     _toPy = {'charm-modified-version': 'charm_modified_version', 'force-upgrade': 'force_upgrade', 'sha256': 'sha256', 'url': 'url'}
 647     def __init__(self, charm_modified_version=None, force_upgrade=None, sha256=None, url=None, **unknown_fields):
 648         '''
 649         charm_modified_version : int
 650         force_upgrade : bool
 651         sha256 : str
 652         url : str
 653         '''
 654         self.charm_modified_version = charm_modified_version
 655         self.force_upgrade = force_upgrade
 656         self.sha256 = sha256
 657         self.url = url
 658
 659
 660
 661 class ApplicationCharmActionsResult(Type):
 662     _toSchema = {'actions': 'actions', 'application_tag': 'application-tag', 'error': 'error'}
 663     _toPy = {'actions': 'actions', 'application-tag': 'application_tag', 'error': 'error'}
 664     def __init__(self, actions=None, application_tag=None, error=None, **unknown_fields):
 665         '''
 666         actions : typing.Mapping[str, ~ActionSpec]
 667         application_tag : str
 668         error : Error
 669         '''
 670         self.actions = actions
 671         self.application_tag = application_tag
 672         self.error = Error.from_json(error) if error else None
 673
 674
 675
 676 class ApplicationCharmRelations(Type):
 677     _toSchema = {'application': 'application'}
 678     _toPy = {'application': 'application'}
 679     def __init__(self, application=None, **unknown_fields):
 680         '''
 681         application : str
 682         '''
 683         self.application = application
 684
 685
 686
 687 class ApplicationCharmRelationsResults(Type):
 688     _toSchema = {'charm_relations': 'charm-relations'}
 689     _toPy = {'charm-relations': 'charm_relations'}
 690     def __init__(self, charm_relations=None, **unknown_fields):
 691         '''
 692         charm_relations : typing.Sequence[str]
 693         '''
 694         self.charm_relations = charm_relations
 695
 696
 697
 698 class ApplicationCharmResult(Type):
 699     _toSchema = {'error': 'error', 'result': 'result'}
 700     _toPy = {'error': 'error', 'result': 'result'}
 701     def __init__(self, error=None, result=None, **unknown_fields):
 702         '''
 703         error : Error
 704         result : ApplicationCharm
 705         '''
 706         self.error = Error.from_json(error) if error else None
 707         self.result = ApplicationCharm.from_json(result) if result else None
 708
 709
 710
 711 class ApplicationCharmResults(Type):
 712     _toSchema = {'results': 'results'}
 713     _toPy = {'results': 'results'}
 714     def __init__(self, results=None, **unknown_fields):
 715         '''
 716         results : typing.Sequence[~ApplicationCharmResult]
 717         '''
 718         self.results = [ApplicationCharmResult.from_json(o) for o in results or []]
 719
 720
 721
 722 class ApplicationConfigSet(Type):
 723     _toSchema = {'application': 'application', 'config': 'config'}
 724     _toPy = {'application': 'application', 'config': 'config'}
 725     def __init__(self, application=None, config=None, **unknown_fields):
 726         '''
 727         application : str
 728         config : typing.Mapping[str, str]
 729         '''
 730         self.application = application
 731         self.config = config
 732
 733
 734
 735 class ApplicationConfigSetArgs(Type):
 736     _toSchema = {'args': 'Args'}
 737     _toPy = {'Args': 'args'}
 738     def __init__(self, args=None, **unknown_fields):
 739         '''
 740         args : typing.Sequence[~ApplicationConfigSet]
 741         '''
 742         self.args = [ApplicationConfigSet.from_json(o) for o in args or []]
 743
 744
 745
 746 class ApplicationConfigUnsetArgs(Type):
 747     _toSchema = {'args': 'Args'}
 748     _toPy = {'Args': 'args'}
 749     def __init__(self, args=None, **unknown_fields):
 750         '''
 751         args : typing.Sequence[~ApplicationUnset]
 752         '''
 753         self.args = [ApplicationUnset.from_json(o) for o in args or []]
 754
 755
 756
 757 class ApplicationConstraint(Type):
 758     _toSchema = {'constraints': 'constraints', 'error': 'error'}
 759     _toPy = {'constraints': 'constraints', 'error': 'error'}
 760     def __init__(self, constraints=None, error=None, **unknown_fields):
 761         '''
 762         constraints : Value
 763         error : Error
 764         '''
 765         self.constraints = Value.from_json(constraints) if constraints else None
 766         self.error = Error.from_json(error) if error else None
 767
 768
 769
 770 class ApplicationDeploy(Type):
 771     _toSchema = {'application': 'application', 'attach_storage': 'attach-storage', 'channel': 'channel', 'charm_url': 'charm-url', 'config': 'config', 'config_yaml': 'config-yaml', 'constraints': 'constraints', 'devices': 'devices', 'endpoint_bindings': 'endpoint-bindings', 'num_units': 'num-units', 'placement': 'placement', 'policy': 'policy', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
 772     _toPy = {'application': 'application', 'attach-storage': 'attach_storage', 'channel': 'channel', 'charm-url': 'charm_url', 'config': 'config', 'config-yaml': 'config_yaml', 'constraints': 'constraints', 'devices': 'devices', 'endpoint-bindings': 'endpoint_bindings', 'num-units': 'num_units', 'placement': 'placement', 'policy': 'policy', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
 773     def __init__(self, application=None, attach_storage=None, channel=None, charm_url=None, config=None, config_yaml=None, constraints=None, devices=None, endpoint_bindings=None, num_units=None, placement=None, policy=None, resources=None, series=None, storage=None, **unknown_fields):
 774         '''
 775         application : str
 776         attach_storage : typing.Sequence[str]
 777         channel : str
 778         charm_url : str
 779         config : typing.Mapping[str, str]
 780         config_yaml : str
 781         constraints : Value
 782         devices : typing.Mapping[str, ~Constraints]
 783         endpoint_bindings : typing.Mapping[str, str]
 784         num_units : int
 785         placement : typing.Sequence[~Placement]
 786         policy : str
 787         resources : typing.Mapping[str, str]
 788         series : str
 789         storage : typing.Mapping[str, ~Constraints]
 790         '''
 791         self.application = application
 792         self.attach_storage = attach_storage
 793         self.channel = channel
 794         self.charm_url = charm_url
 795         self.config = config
 796         self.config_yaml = config_yaml
 797         self.constraints = Value.from_json(constraints) if constraints else None
 798         self.devices = devices
 799         self.endpoint_bindings = endpoint_bindings
 800         self.num_units = num_units
 801         self.placement = [Placement.from_json(o) for o in placement or []]
 802         self.policy = policy
 803         self.resources = resources
 804         self.series = series
 805         self.storage = storage
 806
 807
 808
 809 class ApplicationDestroy(Type):
 810     _toSchema = {'application': 'application'}
 811     _toPy = {'application': 'application'}
 812     def __init__(self, application=None, **unknown_fields):
 813         '''
 814         application : str
 815         '''
 816         self.application = application
 817
 818
 819
 820 class ApplicationExpose(Type):
 821     _toSchema = {'application': 'application'}
 822     _toPy = {'application': 'application'}
 823     def __init__(self, application=None, **unknown_fields):
 824         '''
 825         application : str
 826         '''
 827         self.application = application
 828
 829
 830
 831 class ApplicationGet(Type):
 832     _toSchema = {'application': 'application'}
 833     _toPy = {'application': 'application'}
 834     def __init__(self, application=None, **unknown_fields):
 835         '''
 836         application : str
 837         '''
 838         self.application = application
 839
 840
 841
 842 class ApplicationGetConfigResults(Type):
 843     _toSchema = {'results': 'Results'}
 844     _toPy = {'Results': 'results'}
 845     def __init__(self, results=None, **unknown_fields):
 846         '''
 847         results : typing.Sequence[~ConfigResult]
 848         '''
 849         self.results = [ConfigResult.from_json(o) for o in results or []]
 850
 851
 852
 853 class ApplicationGetConstraintsResults(Type):
 854     _toSchema = {'results': 'results'}
 855     _toPy = {'results': 'results'}
 856     def __init__(self, results=None, **unknown_fields):
 857         '''
 858         results : typing.Sequence[~ApplicationConstraint]
 859         '''
 860         self.results = [ApplicationConstraint.from_json(o) for o in results or []]
 861
 862
 863
 864 class ApplicationGetResults(Type):
 865     _toSchema = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
 866     _toPy = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
 867     def __init__(self, application=None, charm=None, config=None, constraints=None, series=None, **unknown_fields):
 868         '''
 869         application : str
 870         charm : str
 871         config : typing.Mapping[str, typing.Any]
 872         constraints : Value
 873         series : str
 874         '''
 875         self.application = application
 876         self.charm = charm
 877         self.config = config
 878         self.constraints = Value.from_json(constraints) if constraints else None
 879         self.series = series
 880
 881
 882
 883 class ApplicationMetricCredential(Type):
 884     _toSchema = {'application': 'application', 'metrics_credentials': 'metrics-credentials'}
 885     _toPy = {'application': 'application', 'metrics-credentials': 'metrics_credentials'}
 886     def __init__(self, application=None, metrics_credentials=None, **unknown_fields):
 887         '''
 888         application : str
 889         metrics_credentials : typing.Sequence[int]
 890         '''
 891         self.application = application
 892         self.metrics_credentials = metrics_credentials
 893
 894
 895
 896 class ApplicationMetricCredentials(Type):
 897     _toSchema = {'creds': 'creds'}
 898     _toPy = {'creds': 'creds'}
 899     def __init__(self, creds=None, **unknown_fields):
 900         '''
 901         creds : typing.Sequence[~ApplicationMetricCredential]
 902         '''
 903         self.creds = [ApplicationMetricCredential.from_json(o) for o in creds or []]
 904
 905
 906
 907 class ApplicationOffer(Type):
 908     _toSchema = {'access': 'access', 'application_description': 'application-description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer_name': 'offer-name', 'offer_url': 'offer-url', 'source_model_tag': 'source-model-tag', 'spaces': 'spaces'}
 909     _toPy = {'access': 'access', 'application-description': 'application_description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer-name': 'offer_name', 'offer-url': 'offer_url', 'source-model-tag': 'source_model_tag', 'spaces': 'spaces'}
 910     def __init__(self, access=None, application_description=None, bindings=None, endpoints=None, offer_name=None, offer_url=None, source_model_tag=None, spaces=None, **unknown_fields):
 911         '''
 912         access : str
 913         application_description : str
 914         bindings : typing.Mapping[str, str]
 915         endpoints : typing.Sequence[~RemoteEndpoint]
 916         offer_name : str
 917         offer_url : str
 918         source_model_tag : str
 919         spaces : typing.Sequence[~RemoteSpace]
 920         '''
 921         self.access = access
 922         self.application_description = application_description
 923         self.bindings = bindings
 924         self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
 925         self.offer_name = offer_name
 926         self.offer_url = offer_url
 927         self.source_model_tag = source_model_tag
 928         self.spaces = [RemoteSpace.from_json(o) for o in spaces or []]
 929
 930
 931
 932 class ApplicationOfferAdminDetails(Type):
 933     _toSchema = {'application_name': 'application-name', 'applicationofferdetails': 'ApplicationOfferDetails', 'charm_url': 'charm-url', 'connections': 'connections'}
 934     _toPy = {'ApplicationOfferDetails': 'applicationofferdetails', 'application-name': 'application_name', 'charm-url': 'charm_url', 'connections': 'connections'}
 935     def __init__(self, applicationofferdetails=None, application_name=None, charm_url=None, connections=None, **unknown_fields):
 936         '''
 937         applicationofferdetails : ApplicationOfferDetails
 938         application_name : str
 939         charm_url : str
 940         connections : typing.Sequence[~OfferConnection]
 941         '''
 942         self.applicationofferdetails = ApplicationOfferDetails.from_json(applicationofferdetails) if applicationofferdetails else None
 943         self.application_name = application_name
 944         self.charm_url = charm_url
 945         self.connections = [OfferConnection.from_json(o) for o in connections or []]
 946
 947
 948
 949 class ApplicationOfferDetails(Type):
 950     _toSchema = {'application_description': 'application-description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer_name': 'offer-name', 'offer_url': 'offer-url', 'offer_uuid': 'offer-uuid', 'source_model_tag': 'source-model-tag', 'spaces': 'spaces', 'users': 'users'}
 951     _toPy = {'application-description': 'application_description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer-name': 'offer_name', 'offer-url': 'offer_url', 'offer-uuid': 'offer_uuid', 'source-model-tag': 'source_model_tag', 'spaces': 'spaces', 'users': 'users'}
 952     def __init__(self, application_description=None, bindings=None, endpoints=None, offer_name=None, offer_url=None, offer_uuid=None, source_model_tag=None, spaces=None, users=None, **unknown_fields):
 953         '''
 954         application_description : str
 955         bindings : typing.Mapping[str, str]
 956         endpoints : typing.Sequence[~RemoteEndpoint]
 957         offer_name : str
 958         offer_url : str
 959         offer_uuid : str
 960         source_model_tag : str
 961         spaces : typing.Sequence[~RemoteSpace]
 962         users : typing.Sequence[~OfferUserDetails]
 963         '''
 964         self.application_description = application_description
 965         self.bindings = bindings
 966         self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
 967         self.offer_name = offer_name
 968         self.offer_url = offer_url
 969         self.offer_uuid = offer_uuid
 970         self.source_model_tag = source_model_tag
 971         self.spaces = [RemoteSpace.from_json(o) for o in spaces or []]
 972         self.users = [OfferUserDetails.from_json(o) for o in users or []]
 973
 974
 975
 976 class ApplicationOfferResult(Type):
 977     _toSchema = {'error': 'error', 'result': 'result'}
 978     _toPy = {'error': 'error', 'result': 'result'}
 979     def __init__(self, error=None, result=None, **unknown_fields):
 980         '''
 981         error : Error
 982         result : ApplicationOfferAdminDetails
 983         '''
 984         self.error = Error.from_json(error) if error else None
 985         self.result = ApplicationOfferAdminDetails.from_json(result) if result else None
 986
 987
 988
 989 class ApplicationOfferStatus(Type):
 990     _toSchema = {'active_connected_count': 'active-connected-count', 'application_name': 'application-name', 'charm': 'charm', 'endpoints': 'endpoints', 'err': 'err', 'offer_name': 'offer-name', 'total_connected_count': 'total-connected-count'}
 991     _toPy = {'active-connected-count': 'active_connected_count', 'application-name': 'application_name', 'charm': 'charm', 'endpoints': 'endpoints', 'err': 'err', 'offer-name': 'offer_name', 'total-connected-count': 'total_connected_count'}
 992     def __init__(self, active_connected_count=None, application_name=None, charm=None, endpoints=None, err=None, offer_name=None, total_connected_count=None, **unknown_fields):
 993         '''
 994         active_connected_count : int
 995         application_name : str
 996         charm : str
 997         endpoints : typing.Mapping[str, ~RemoteEndpoint]
 998         err : typing.Mapping[str, typing.Any]
 999         offer_name : str
1000         total_connected_count : int
1001         '''
1002         self.active_connected_count = active_connected_count
1003         self.application_name = application_name
1004         self.charm = charm
1005         self.endpoints = endpoints
1006         self.err = err
1007         self.offer_name = offer_name
1008         self.total_connected_count = total_connected_count
1009
1010
1011
1012 class ApplicationOffersResults(Type):
1013     _toSchema = {'results': 'results'}
1014     _toPy = {'results': 'results'}
1015     def __init__(self, results=None, **unknown_fields):
1016         '''
1017         results : typing.Sequence[~ApplicationOfferResult]
1018         '''
1019         self.results = [ApplicationOfferResult.from_json(o) for o in results or []]
1020
1021
1022
1023 class ApplicationRelationsChange(Type):
1024     _toSchema = {'changed': 'changed', 'removed': 'removed'}
1025     _toPy = {'changed': 'changed', 'removed': 'removed'}
1026     def __init__(self, changed=None, removed=None, **unknown_fields):
1027         '''
1028         changed : typing.Sequence[~RelationChange]
1029         removed : typing.Sequence[int]
1030         '''
1031         self.changed = [RelationChange.from_json(o) for o in changed or []]
1032         self.removed = removed
1033
1034
1035
1036 class ApplicationRelationsWatchResult(Type):
1037     _toSchema = {'applicationrelationswatcherid': 'ApplicationRelationsWatcherId', 'changes': 'changes', 'error': 'error'}
1038     _toPy = {'ApplicationRelationsWatcherId': 'applicationrelationswatcherid', 'changes': 'changes', 'error': 'error'}
1039     def __init__(self, applicationrelationswatcherid=None, changes=None, error=None, **unknown_fields):
1040         '''
1041         applicationrelationswatcherid : str
1042         changes : ApplicationRelationsChange
1043         error : Error
1044         '''
1045         self.applicationrelationswatcherid = applicationrelationswatcherid
1046         self.changes = ApplicationRelationsChange.from_json(changes) if changes else None
1047         self.error = Error.from_json(error) if error else None
1048
1049
1050
1051 class ApplicationSet(Type):
1052     _toSchema = {'application': 'application', 'options': 'options'}
1053     _toPy = {'application': 'application', 'options': 'options'}
1054     def __init__(self, application=None, options=None, **unknown_fields):
1055         '''
1056         application : str
1057         options : typing.Mapping[str, str]
1058         '''
1059         self.application = application
1060         self.options = options
1061
1062
1063
1064 class ApplicationSetCharm(Type):
1065     _toSchema = {'application': 'application', 'channel': 'channel', 'charm_url': 'charm-url', 'config_settings': 'config-settings', 'config_settings_yaml': 'config-settings-yaml', 'force_series': 'force-series', 'force_units': 'force-units', 'resource_ids': 'resource-ids', 'storage_constraints': 'storage-constraints'}
1066     _toPy = {'application': 'application', 'channel': 'channel', 'charm-url': 'charm_url', 'config-settings': 'config_settings', 'config-settings-yaml': 'config_settings_yaml', 'force-series': 'force_series', 'force-units': 'force_units', 'resource-ids': 'resource_ids', 'storage-constraints': 'storage_constraints'}
1067     def __init__(self, application=None, channel=None, charm_url=None, config_settings=None, config_settings_yaml=None, force_series=None, force_units=None, resource_ids=None, storage_constraints=None, **unknown_fields):
1068         '''
1069         application : str
1070         channel : str
1071         charm_url : str
1072         config_settings : typing.Mapping[str, str]
1073         config_settings_yaml : str
1074         force_series : bool
1075         force_units : bool
1076         resource_ids : typing.Mapping[str, str]
1077         storage_constraints : typing.Mapping[str, ~StorageConstraints]
1078         '''
1079         self.application = application
1080         self.channel = channel
1081         self.charm_url = charm_url
1082         self.config_settings = config_settings
1083         self.config_settings_yaml = config_settings_yaml
1084         self.force_series = force_series
1085         self.force_units = force_units
1086         self.resource_ids = resource_ids
1087         self.storage_constraints = storage_constraints
1088
1089
1090
1091 class ApplicationSetCharmProfile(Type):
1092     _toSchema = {'application': 'application', 'charm_url': 'charm-url'}
1093     _toPy = {'application': 'application', 'charm-url': 'charm_url'}
1094     def __init__(self, application=None, charm_url=None, **unknown_fields):
1095         '''
1096         application : str
1097         charm_url : str
1098         '''
1099         self.application = application
1100         self.charm_url = charm_url
1101
1102
1103
1104 class ApplicationStatus(Type):
1105     _toSchema = {'can_upgrade_to': 'can-upgrade-to', 'charm': 'charm', 'err': 'err', 'exposed': 'exposed', 'life': 'life', 'meter_statuses': 'meter-statuses', 'relations': 'relations', 'series': 'series', 'status': 'status', 'subordinate_to': 'subordinate-to', 'units': 'units', 'workload_version': 'workload-version'}
1106     _toPy = {'can-upgrade-to': 'can_upgrade_to', 'charm': 'charm', 'err': 'err', 'exposed': 'exposed', 'life': 'life', 'meter-statuses': 'meter_statuses', 'relations': 'relations', 'series': 'series', 'status': 'status', 'subordinate-to': 'subordinate_to', 'units': 'units', 'workload-version': 'workload_version'}
1107     def __init__(self, can_upgrade_to=None, charm=None, err=None, exposed=None, life=None, meter_statuses=None, relations=None, series=None, status=None, subordinate_to=None, units=None, workload_version=None, **unknown_fields):
1108         '''
1109         can_upgrade_to : str
1110         charm : str
1111         err : typing.Mapping[str, typing.Any]
1112         exposed : bool
1113         life : str
1114         meter_statuses : typing.Mapping[str, ~MeterStatus]
1115         relations : typing.Sequence[str]
1116         series : str
1117         status : DetailedStatus
1118         subordinate_to : typing.Sequence[str]
1119         units : typing.Mapping[str, ~UnitStatus]
1120         workload_version : str
1121         '''
1122         self.can_upgrade_to = can_upgrade_to
1123         self.charm = charm
1124         self.err = err
1125         self.exposed = exposed
1126         self.life = life
1127         self.meter_statuses = meter_statuses
1128         self.relations = relations
1129         self.series = series
1130         self.status = DetailedStatus.from_json(status) if status else None
1131         self.subordinate_to = subordinate_to
1132         self.units = units
1133         self.workload_version = workload_version
1134
1135
1136
1137 class ApplicationStatusResult(Type):
1138     _toSchema = {'application': 'application', 'error': 'error', 'units': 'units'}
1139     _toPy = {'application': 'application', 'error': 'error', 'units': 'units'}
1140     def __init__(self, application=None, error=None, units=None, **unknown_fields):
1141         '''
1142         application : StatusResult
1143         error : Error
1144         units : typing.Mapping[str, ~StatusResult]
1145         '''
1146         self.application = StatusResult.from_json(application) if application else None
1147         self.error = Error.from_json(error) if error else None
1148         self.units = units
1149
1150
1151
1152 class ApplicationStatusResults(Type):
1153     _toSchema = {'results': 'results'}
1154     _toPy = {'results': 'results'}
1155     def __init__(self, results=None, **unknown_fields):
1156         '''
1157         results : typing.Sequence[~ApplicationStatusResult]
1158         '''
1159         self.results = [ApplicationStatusResult.from_json(o) for o in results or []]
1160
1161
1162
1163 class ApplicationTag(Type):
1164     _toSchema = {'name': 'Name'}
1165     _toPy = {'Name': 'name'}
1166     def __init__(self, name=None, **unknown_fields):
1167         '''
1168         name : str
1169         '''
1170         self.name = name
1171
1172
1173
1174 class ApplicationURLs(Type):
1175     _toSchema = {'application_urls': 'application-urls'}
1176     _toPy = {'application-urls': 'application_urls'}
1177     def __init__(self, application_urls=None, **unknown_fields):
1178         '''
1179         application_urls : typing.Sequence[str]
1180         '''
1181         self.application_urls = application_urls
1182
1183
1184
1185 class ApplicationUnexpose(Type):
1186     _toSchema = {'application': 'application'}
1187     _toPy = {'application': 'application'}
1188     def __init__(self, application=None, **unknown_fields):
1189         '''
1190         application : str
1191         '''
1192         self.application = application
1193
1194
1195
1196 class ApplicationUnitParams(Type):
1197     _toSchema = {'address': 'address', 'data': 'data', 'filesystem_info': 'filesystem-info', 'info': 'info', 'ports': 'ports', 'provider_id': 'provider-id', 'status': 'status', 'unit_tag': 'unit-tag'}
1198     _toPy = {'address': 'address', 'data': 'data', 'filesystem-info': 'filesystem_info', 'info': 'info', 'ports': 'ports', 'provider-id': 'provider_id', 'status': 'status', 'unit-tag': 'unit_tag'}
1199     def __init__(self, address=None, data=None, filesystem_info=None, info=None, ports=None, provider_id=None, status=None, unit_tag=None, **unknown_fields):
1200         '''
1201         address : str
1202         data : typing.Mapping[str, typing.Any]
1203         filesystem_info : typing.Sequence[~KubernetesFilesystemInfo]
1204         info : str
1205         ports : typing.Sequence[str]
1206         provider_id : str
1207         status : str
1208         unit_tag : str
1209         '''
1210         self.address = address
1211         self.data = data
1212         self.filesystem_info = [KubernetesFilesystemInfo.from_json(o) for o in filesystem_info or []]
1213         self.info = info
1214         self.ports = ports
1215         self.provider_id = provider_id
1216         self.status = status
1217         self.unit_tag = unit_tag
1218
1219
1220
1221 class ApplicationUnset(Type):
1222     _toSchema = {'application': 'application', 'options': 'options'}
1223     _toPy = {'application': 'application', 'options': 'options'}
1224     def __init__(self, application=None, options=None, **unknown_fields):
1225         '''
1226         application : str
1227         options : typing.Sequence[str]
1228         '''
1229         self.application = application
1230         self.options = options
1231
1232
1233
1234 class ApplicationUpdate(Type):
1235     _toSchema = {'application': 'application', 'charm_url': 'charm-url', 'constraints': 'constraints', 'force_charm_url': 'force-charm-url', 'force_series': 'force-series', 'min_units': 'min-units', 'settings': 'settings', 'settings_yaml': 'settings-yaml'}
1236     _toPy = {'application': 'application', 'charm-url': 'charm_url', 'constraints': 'constraints', 'force-charm-url': 'force_charm_url', 'force-series': 'force_series', 'min-units': 'min_units', 'settings': 'settings', 'settings-yaml': 'settings_yaml'}
1237     def __init__(self, application=None, charm_url=None, constraints=None, force_charm_url=None, force_series=None, min_units=None, settings=None, settings_yaml=None, **unknown_fields):
1238         '''
1239         application : str
1240         charm_url : str
1241         constraints : Value
1242         force_charm_url : bool
1243         force_series : bool
1244         min_units : int
1245         settings : typing.Mapping[str, str]
1246         settings_yaml : str
1247         '''
1248         self.application = application
1249         self.charm_url = charm_url
1250         self.constraints = Value.from_json(constraints) if constraints else None
1251         self.force_charm_url = force_charm_url
1252         self.force_series = force_series
1253         self.min_units = min_units
1254         self.settings = settings
1255         self.settings_yaml = settings_yaml
1256
1257
1258
1259 class ApplicationsCharmActionsResults(Type):
1260     _toSchema = {'results': 'results'}
1261     _toPy = {'results': 'results'}
1262     def __init__(self, results=None, **unknown_fields):
1263         '''
1264         results : typing.Sequence[~ApplicationCharmActionsResult]
1265         '''
1266         self.results = [ApplicationCharmActionsResult.from_json(o) for o in results or []]
1267
1268
1269
1270 class ApplicationsDeploy(Type):
1271     _toSchema = {'applications': 'applications'}
1272     _toPy = {'applications': 'applications'}
1273     def __init__(self, applications=None, **unknown_fields):
1274         '''
1275         applications : typing.Sequence[~ApplicationDeploy]
1276         '''
1277         self.applications = [ApplicationDeploy.from_json(o) for o in applications or []]
1278
1279
1280
1281 class BackupsCreateArgs(Type):
1282     _toSchema = {'notes': 'notes'}
1283     _toPy = {'notes': 'notes'}
1284     def __init__(self, notes=None, **unknown_fields):
1285         '''
1286         notes : str
1287         '''
1288         self.notes = notes
1289
1290
1291
1292 class BackupsInfoArgs(Type):
1293     _toSchema = {'id_': 'id'}
1294     _toPy = {'id': 'id_'}
1295     def __init__(self, id_=None, **unknown_fields):
1296         '''
1297         id_ : str
1298         '''
1299         self.id_ = id_
1300
1301
1302
1303 class BackupsListArgs(Type):
1304     _toSchema = {}
1305     _toPy = {}
1306     def __init__(self, **unknown_fields):
1307         '''
1308
1309         '''
1310         pass
1311
1312
1313
1314 class BackupsListResult(Type):
1315     _toSchema = {'list_': 'list'}
1316     _toPy = {'list': 'list_'}
1317     def __init__(self, list_=None, **unknown_fields):
1318         '''
1319         list_ : typing.Sequence[~BackupsMetadataResult]
1320         '''
1321         self.list_ = [BackupsMetadataResult.from_json(o) for o in list_ or []]
1322
1323
1324
1325 class BackupsMetadataResult(Type):
1326     _toSchema = {'ca_cert': 'ca-cert', 'ca_private_key': 'ca-private-key', 'checksum': 'checksum', 'checksum_format': 'checksum-format', 'finished': 'finished', 'hostname': 'hostname', 'id_': 'id', 'machine': 'machine', 'model': 'model', 'notes': 'notes', 'series': 'series', 'size': 'size', 'started': 'started', 'stored': 'stored', 'version': 'version'}
1327     _toPy = {'ca-cert': 'ca_cert', 'ca-private-key': 'ca_private_key', 'checksum': 'checksum', 'checksum-format': 'checksum_format', 'finished': 'finished', 'hostname': 'hostname', 'id': 'id_', 'machine': 'machine', 'model': 'model', 'notes': 'notes', 'series': 'series', 'size': 'size', 'started': 'started', 'stored': 'stored', 'version': 'version'}
1328     def __init__(self, ca_cert=None, ca_private_key=None, checksum=None, checksum_format=None, finished=None, hostname=None, id_=None, machine=None, model=None, notes=None, series=None, size=None, started=None, stored=None, version=None, **unknown_fields):
1329         '''
1330         ca_cert : str
1331         ca_private_key : str
1332         checksum : str
1333         checksum_format : str
1334         finished : str
1335         hostname : str
1336         id_ : str
1337         machine : str
1338         model : str
1339         notes : str
1340         series : str
1341         size : int
1342         started : str
1343         stored : str
1344         version : Number
1345         '''
1346         self.ca_cert = ca_cert
1347         self.ca_private_key = ca_private_key
1348         self.checksum = checksum
1349         self.checksum_format = checksum_format
1350         self.finished = finished
1351         self.hostname = hostname
1352         self.id_ = id_
1353         self.machine = machine
1354         self.model = model
1355         self.notes = notes
1356         self.series = series
1357         self.size = size
1358         self.started = started
1359         self.stored = stored
1360         self.version = Number.from_json(version) if version else None
1361
1362
1363
1364 class BackupsRemoveArgs(Type):
1365     _toSchema = {'id_': 'id'}
1366     _toPy = {'id': 'id_'}
1367     def __init__(self, id_=None, **unknown_fields):
1368         '''
1369         id_ : str
1370         '''
1371         self.id_ = id_
1372
1373
1374
1375 class Binary(Type):
1376     _toSchema = {'arch': 'Arch', 'number': 'Number', 'series': 'Series'}
1377     _toPy = {'Arch': 'arch', 'Number': 'number', 'Series': 'series'}
1378     def __init__(self, arch=None, number=None, series=None, **unknown_fields):
1379         '''
1380         arch : str
1381         number : Number
1382         series : str
1383         '''
1384         self.arch = arch
1385         self.number = Number.from_json(number) if number else None
1386         self.series = series
1387
1388
1389
1390 class Block(Type):
1391     _toSchema = {'id_': 'id', 'message': 'message', 'tag': 'tag', 'type_': 'type'}
1392     _toPy = {'id': 'id_', 'message': 'message', 'tag': 'tag', 'type': 'type_'}
1393     def __init__(self, id_=None, message=None, tag=None, type_=None, **unknown_fields):
1394         '''
1395         id_ : str
1396         message : str
1397         tag : str
1398         type_ : str
1399         '''
1400         self.id_ = id_
1401         self.message = message
1402         self.tag = tag
1403         self.type_ = type_
1404
1405
1406
1407 class BlockDevice(Type):
1408     _toSchema = {'busaddress': 'BusAddress', 'devicelinks': 'DeviceLinks', 'devicename': 'DeviceName', 'filesystemtype': 'FilesystemType', 'hardwareid': 'HardwareId', 'inuse': 'InUse', 'label': 'Label', 'mountpoint': 'MountPoint', 'size': 'Size', 'uuid': 'UUID'}
1409     _toPy = {'BusAddress': 'busaddress', 'DeviceLinks': 'devicelinks', 'DeviceName': 'devicename', 'FilesystemType': 'filesystemtype', 'HardwareId': 'hardwareid', 'InUse': 'inuse', 'Label': 'label', 'MountPoint': 'mountpoint', 'Size': 'size', 'UUID': 'uuid'}
1410     def __init__(self, busaddress=None, devicelinks=None, devicename=None, filesystemtype=None, hardwareid=None, inuse=None, label=None, mountpoint=None, size=None, uuid=None, **unknown_fields):
1411         '''
1412         busaddress : str
1413         devicelinks : typing.Sequence[str]
1414         devicename : str
1415         filesystemtype : str
1416         hardwareid : str
1417         inuse : bool
1418         label : str
1419         mountpoint : str
1420         size : int
1421         uuid : str
1422         '''
1423         self.busaddress = busaddress
1424         self.devicelinks = devicelinks
1425         self.devicename = devicename
1426         self.filesystemtype = filesystemtype
1427         self.hardwareid = hardwareid
1428         self.inuse = inuse
1429         self.label = label
1430         self.mountpoint = mountpoint
1431         self.size = size
1432         self.uuid = uuid
1433
1434
1435
1436 class BlockDeviceResult(Type):
1437     _toSchema = {'error': 'error', 'result': 'result'}
1438     _toPy = {'error': 'error', 'result': 'result'}
1439     def __init__(self, error=None, result=None, **unknown_fields):
1440         '''
1441         error : Error
1442         result : BlockDevice
1443         '''
1444         self.error = Error.from_json(error) if error else None
1445         self.result = BlockDevice.from_json(result) if result else None
1446
1447
1448
1449 class BlockDeviceResults(Type):
1450     _toSchema = {'results': 'results'}
1451     _toPy = {'results': 'results'}
1452     def __init__(self, results=None, **unknown_fields):
1453         '''
1454         results : typing.Sequence[~BlockDeviceResult]
1455         '''
1456         self.results = [BlockDeviceResult.from_json(o) for o in results or []]
1457
1458
1459
1460 class BlockResult(Type):
1461     _toSchema = {'error': 'error', 'result': 'result'}
1462     _toPy = {'error': 'error', 'result': 'result'}
1463     def __init__(self, error=None, result=None, **unknown_fields):
1464         '''
1465         error : Error
1466         result : Block
1467         '''
1468         self.error = Error.from_json(error) if error else None
1469         self.result = Block.from_json(result) if result else None
1470
1471
1472
1473 class BlockResults(Type):
1474     _toSchema = {'results': 'results'}
1475     _toPy = {'results': 'results'}
1476     def __init__(self, results=None, **unknown_fields):
1477         '''
1478         results : typing.Sequence[~BlockResult]
1479         '''
1480         self.results = [BlockResult.from_json(o) for o in results or []]
1481
1482
1483
1484 class BlockSwitchParams(Type):
1485     _toSchema = {'message': 'message', 'type_': 'type'}
1486     _toPy = {'message': 'message', 'type': 'type_'}
1487     def __init__(self, message=None, type_=None, **unknown_fields):
1488         '''
1489         message : str
1490         type_ : str
1491         '''
1492         self.message = message
1493         self.type_ = type_
1494
1495
1496
1497 class BoolResult(Type):
1498     _toSchema = {'error': 'error', 'result': 'result'}
1499     _toPy = {'error': 'error', 'result': 'result'}
1500     def __init__(self, error=None, result=None, **unknown_fields):
1501         '''
1502         error : Error
1503         result : bool
1504         '''
1505         self.error = Error.from_json(error) if error else None
1506         self.result = result
1507
1508
1509
1510 class BoolResults(Type):
1511     _toSchema = {'results': 'results'}
1512     _toPy = {'results': 'results'}
1513     def __init__(self, results=None, **unknown_fields):
1514         '''
1515         results : typing.Sequence[~BoolResult]
1516         '''
1517         self.results = [BoolResult.from_json(o) for o in results or []]
1518
1519
1520
1521 class BulkImportStorageParams(Type):
1522     _toSchema = {'storage': 'storage'}
1523     _toPy = {'storage': 'storage'}
1524     def __init__(self, storage=None, **unknown_fields):
1525         '''
1526         storage : typing.Sequence[~ImportStorageParams]
1527         '''
1528         self.storage = [ImportStorageParams.from_json(o) for o in storage or []]
1529
1530
1531
1532 class BundleChange(Type):
1533     _toSchema = {'args': 'args', 'id_': 'id', 'method': 'method', 'requires': 'requires'}
1534     _toPy = {'args': 'args', 'id': 'id_', 'method': 'method', 'requires': 'requires'}
1535     def __init__(self, args=None, id_=None, method=None, requires=None, **unknown_fields):
1536         '''
1537         args : typing.Sequence[typing.Any]
1538         id_ : str
1539         method : str
1540         requires : typing.Sequence[str]
1541         '''
1542         self.args = args
1543         self.id_ = id_
1544         self.method = method
1545         self.requires = requires
1546
1547
1548
1549 class BundleChangesParams(Type):
1550     _toSchema = {'yaml': 'yaml'}
1551     _toPy = {'yaml': 'yaml'}
1552     def __init__(self, yaml=None, **unknown_fields):
1553         '''
1554         yaml : str
1555         '''
1556         self.yaml = yaml
1557
1558
1559
1560 class BundleChangesResults(Type):
1561     _toSchema = {'changes': 'changes', 'errors': 'errors'}
1562     _toPy = {'changes': 'changes', 'errors': 'errors'}
1563     def __init__(self, changes=None, errors=None, **unknown_fields):
1564         '''
1565         changes : typing.Sequence[~BundleChange]
1566         errors : typing.Sequence[str]
1567         '''
1568         self.changes = [BundleChange.from_json(o) for o in changes or []]
1569         self.errors = errors
1570
1571
1572
1573 class BytesResult(Type):
1574     _toSchema = {'result': 'result'}
1575     _toPy = {'result': 'result'}
1576     def __init__(self, result=None, **unknown_fields):
1577         '''
1578         result : typing.Sequence[int]
1579         '''
1580         self.result = result
1581
1582
1583
1584 class ChangeModelCredentialParams(Type):
1585     _toSchema = {'credential_tag': 'credential-tag', 'model_tag': 'model-tag'}
1586     _toPy = {'credential-tag': 'credential_tag', 'model-tag': 'model_tag'}
1587     def __init__(self, credential_tag=None, model_tag=None, **unknown_fields):
1588         '''
1589         credential_tag : str
1590         model_tag : str
1591         '''
1592         self.credential_tag = credential_tag
1593         self.model_tag = model_tag
1594
1595
1596
1597 class ChangeModelCredentialsParams(Type):
1598     _toSchema = {'model_credentials': 'model-credentials'}
1599     _toPy = {'model-credentials': 'model_credentials'}
1600     def __init__(self, model_credentials=None, **unknown_fields):
1601         '''
1602         model_credentials : typing.Sequence[~ChangeModelCredentialParams]
1603         '''
1604         self.model_credentials = [ChangeModelCredentialParams.from_json(o) for o in model_credentials or []]
1605
1606
1607
1608 class CharmActionSpec(Type):
1609     _toSchema = {'description': 'description', 'params': 'params'}
1610     _toPy = {'description': 'description', 'params': 'params'}
1611     def __init__(self, description=None, params=None, **unknown_fields):
1612         '''
1613         description : str
1614         params : typing.Mapping[str, typing.Any]
1615         '''
1616         self.description = description
1617         self.params = params
1618
1619
1620
1621 class CharmActions(Type):
1622     _toSchema = {'specs': 'specs'}
1623     _toPy = {'specs': 'specs'}
1624     def __init__(self, specs=None, **unknown_fields):
1625         '''
1626         specs : typing.Mapping[str, ~CharmActionSpec]
1627         '''
1628         self.specs = specs
1629
1630
1631
1632 class CharmDevice(Type):
1633     _toSchema = {'countmax': 'CountMax', 'countmin': 'CountMin', 'description': 'Description', 'name': 'Name', 'type_': 'Type'}
1634     _toPy = {'CountMax': 'countmax', 'CountMin': 'countmin', 'Description': 'description', 'Name': 'name', 'Type': 'type_'}
1635     def __init__(self, countmax=None, countmin=None, description=None, name=None, type_=None, **unknown_fields):
1636         '''
1637         countmax : int
1638         countmin : int
1639         description : str
1640         name : str
1641         type_ : str
1642         '''
1643         self.countmax = countmax
1644         self.countmin = countmin
1645         self.description = description
1646         self.name = name
1647         self.type_ = type_
1648
1649
1650
1651 class CharmInfo(Type):
1652     _toSchema = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
1653     _toPy = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
1654     def __init__(self, actions=None, config=None, meta=None, metrics=None, revision=None, url=None, **unknown_fields):
1655         '''
1656         actions : CharmActions
1657         config : typing.Mapping[str, ~CharmOption]
1658         meta : CharmMeta
1659         metrics : CharmMetrics
1660         revision : int
1661         url : str
1662         '''
1663         self.actions = CharmActions.from_json(actions) if actions else None
1664         self.config = config
1665         self.meta = CharmMeta.from_json(meta) if meta else None
1666         self.metrics = CharmMetrics.from_json(metrics) if metrics else None
1667         self.revision = revision
1668         self.url = url
1669
1670
1671
1672 class CharmLXDProfile(Type):
1673     _toSchema = {'config': 'config', 'description': 'description', 'devices': 'devices'}
1674     _toPy = {'config': 'config', 'description': 'description', 'devices': 'devices'}
1675     def __init__(self, config=None, description=None, devices=None, **unknown_fields):
1676         '''
1677         config : typing.Mapping[str, str]
1678         description : str
1679         devices : typing.Mapping[str, typing.Any]
1680         '''
1681         self.config = config
1682         self.description = description
1683         self.devices = devices
1684
1685
1686
1687 class CharmMeta(Type):
1688     _toSchema = {'categories': 'categories', 'description': 'description', 'extra_bindings': 'extra-bindings', 'min_juju_version': 'min-juju-version', 'name': 'name', 'payload_classes': 'payload-classes', 'peers': 'peers', 'provides': 'provides', 'requires': 'requires', 'resources': 'resources', 'series': 'series', 'storage': 'storage', 'subordinate': 'subordinate', 'summary': 'summary', 'tags': 'tags', 'terms': 'terms'}
1689     _toPy = {'categories': 'categories', 'description': 'description', 'extra-bindings': 'extra_bindings', 'min-juju-version': 'min_juju_version', 'name': 'name', 'payload-classes': 'payload_classes', 'peers': 'peers', 'provides': 'provides', 'requires': 'requires', 'resources': 'resources', 'series': 'series', 'storage': 'storage', 'subordinate': 'subordinate', 'summary': 'summary', 'tags': 'tags', 'terms': 'terms'}
1690     def __init__(self, categories=None, description=None, extra_bindings=None, min_juju_version=None, name=None, payload_classes=None, peers=None, provides=None, requires=None, resources=None, series=None, storage=None, subordinate=None, summary=None, tags=None, terms=None, **unknown_fields):
1691         '''
1692         categories : typing.Sequence[str]
1693         description : str
1694         extra_bindings : typing.Mapping[str, str]
1695         min_juju_version : str
1696         name : str
1697         payload_classes : typing.Mapping[str, ~CharmPayloadClass]
1698         peers : typing.Mapping[str, ~CharmRelation]
1699         provides : typing.Mapping[str, ~CharmRelation]
1700         requires : typing.Mapping[str, ~CharmRelation]
1701         resources : typing.Mapping[str, ~CharmResourceMeta]
1702         series : typing.Sequence[str]
1703         storage : typing.Mapping[str, ~CharmStorage]
1704         subordinate : bool
1705         summary : str
1706         tags : typing.Sequence[str]
1707         terms : typing.Sequence[str]
1708         '''
1709         self.categories = categories
1710         self.description = description
1711         self.extra_bindings = extra_bindings
1712         self.min_juju_version = min_juju_version
1713         self.name = name
1714         self.payload_classes = payload_classes
1715         self.peers = peers
1716         self.provides = provides
1717         self.requires = requires
1718         self.resources = resources
1719         self.series = series
1720         self.storage = storage
1721         self.subordinate = subordinate
1722         self.summary = summary
1723         self.tags = tags
1724         self.terms = terms
1725
1726
1727
1728 class CharmMetric(Type):
1729     _toSchema = {'description': 'description', 'type_': 'type'}
1730     _toPy = {'description': 'description', 'type': 'type_'}
1731     def __init__(self, description=None, type_=None, **unknown_fields):
1732         '''
1733         description : str
1734         type_ : str
1735         '''
1736         self.description = description
1737         self.type_ = type_
1738
1739
1740
1741 class CharmMetrics(Type):
1742     _toSchema = {'metrics': 'metrics', 'plan': 'plan'}
1743     _toPy = {'metrics': 'metrics', 'plan': 'plan'}
1744     def __init__(self, metrics=None, plan=None, **unknown_fields):
1745         '''
1746         metrics : typing.Mapping[str, ~CharmMetric]
1747         plan : CharmPlan
1748         '''
1749         self.metrics = metrics
1750         self.plan = CharmPlan.from_json(plan) if plan else None
1751
1752
1753
1754 class CharmOption(Type):
1755     _toSchema = {'default': 'default', 'description': 'description', 'type_': 'type'}
1756     _toPy = {'default': 'default', 'description': 'description', 'type': 'type_'}
1757     def __init__(self, default=None, description=None, type_=None, **unknown_fields):
1758         '''
1759         default : typing.Mapping[str, typing.Any]
1760         description : str
1761         type_ : str
1762         '''
1763         self.default = default
1764         self.description = description
1765         self.type_ = type_
1766
1767
1768
1769 class CharmPayloadClass(Type):
1770     _toSchema = {'name': 'name', 'type_': 'type'}
1771     _toPy = {'name': 'name', 'type': 'type_'}
1772     def __init__(self, name=None, type_=None, **unknown_fields):
1773         '''
1774         name : str
1775         type_ : str
1776         '''
1777         self.name = name
1778         self.type_ = type_
1779
1780
1781
1782 class CharmPlan(Type):
1783     _toSchema = {'required': 'required'}
1784     _toPy = {'required': 'required'}
1785     def __init__(self, required=None, **unknown_fields):
1786         '''
1787         required : bool
1788         '''
1789         self.required = required
1790
1791
1792
1793 class CharmRelation(Type):
1794     _toSchema = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'optional': 'optional', 'role': 'role', 'scope': 'scope'}
1795     _toPy = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'optional': 'optional', 'role': 'role', 'scope': 'scope'}
1796     def __init__(self, interface=None, limit=None, name=None, optional=None, role=None, scope=None, **unknown_fields):
1797         '''
1798         interface : str
1799         limit : int
1800         name : str
1801         optional : bool
1802         role : str
1803         scope : str
1804         '''
1805         self.interface = interface
1806         self.limit = limit
1807         self.name = name
1808         self.optional = optional
1809         self.role = role
1810         self.scope = scope
1811
1812
1813
1814 class CharmResource(Type):
1815     _toSchema = {'description': 'description', 'fingerprint': 'fingerprint', 'name': 'name', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'type_': 'type'}
1816     _toPy = {'description': 'description', 'fingerprint': 'fingerprint', 'name': 'name', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'type': 'type_'}
1817     def __init__(self, description=None, fingerprint=None, name=None, origin=None, path=None, revision=None, size=None, type_=None, **unknown_fields):
1818         '''
1819         description : str
1820         fingerprint : typing.Sequence[int]
1821         name : str
1822         origin : str
1823         path : str
1824         revision : int
1825         size : int
1826         type_ : str
1827         '''
1828         self.description = description
1829         self.fingerprint = fingerprint
1830         self.name = name
1831         self.origin = origin
1832         self.path = path
1833         self.revision = revision
1834         self.size = size
1835         self.type_ = type_
1836
1837
1838
1839 class CharmResourceMeta(Type):
1840     _toSchema = {'description': 'description', 'name': 'name', 'path': 'path', 'type_': 'type'}
1841     _toPy = {'description': 'description', 'name': 'name', 'path': 'path', 'type': 'type_'}
1842     def __init__(self, description=None, name=None, path=None, type_=None, **unknown_fields):
1843         '''
1844         description : str
1845         name : str
1846         path : str
1847         type_ : str
1848         '''
1849         self.description = description
1850         self.name = name
1851         self.path = path
1852         self.type_ = type_
1853
1854
1855
1856 class CharmStorage(Type):
1857     _toSchema = {'count_max': 'count-max', 'count_min': 'count-min', 'description': 'description', 'location': 'location', 'minimum_size': 'minimum-size', 'name': 'name', 'properties': 'properties', 'read_only': 'read-only', 'shared': 'shared', 'type_': 'type'}
1858     _toPy = {'count-max': 'count_max', 'count-min': 'count_min', 'description': 'description', 'location': 'location', 'minimum-size': 'minimum_size', 'name': 'name', 'properties': 'properties', 'read-only': 'read_only', 'shared': 'shared', 'type': 'type_'}
1859     def __init__(self, count_max=None, count_min=None, description=None, location=None, minimum_size=None, name=None, properties=None, read_only=None, shared=None, type_=None, **unknown_fields):
1860         '''
1861         count_max : int
1862         count_min : int
1863         description : str
1864         location : str
1865         minimum_size : int
1866         name : str
1867         properties : typing.Sequence[str]
1868         read_only : bool
1869         shared : bool
1870         type_ : str
1871         '''
1872         self.count_max = count_max
1873         self.count_min = count_min
1874         self.description = description
1875         self.location = location
1876         self.minimum_size = minimum_size
1877         self.name = name
1878         self.properties = properties
1879         self.read_only = read_only
1880         self.shared = shared
1881         self.type_ = type_
1882
1883
1884
1885 class CharmURL(Type):
1886     _toSchema = {'url': 'url'}
1887     _toPy = {'url': 'url'}
1888     def __init__(self, url=None, **unknown_fields):
1889         '''
1890         url : str
1891         '''
1892         self.url = url
1893
1894
1895
1896 class CharmURLs(Type):
1897     _toSchema = {'urls': 'urls'}
1898     _toPy = {'urls': 'urls'}
1899     def __init__(self, urls=None, **unknown_fields):
1900         '''
1901         urls : typing.Sequence[~CharmURL]
1902         '''
1903         self.urls = [CharmURL.from_json(o) for o in urls or []]
1904
1905
1906
1907 class CharmsList(Type):
1908     _toSchema = {'names': 'names'}
1909     _toPy = {'names': 'names'}
1910     def __init__(self, names=None, **unknown_fields):
1911         '''
1912         names : typing.Sequence[str]
1913         '''
1914         self.names = names
1915
1916
1917
1918 class CharmsListResult(Type):
1919     _toSchema = {'charm_urls': 'charm-urls'}
1920     _toPy = {'charm-urls': 'charm_urls'}
1921     def __init__(self, charm_urls=None, **unknown_fields):
1922         '''
1923         charm_urls : typing.Sequence[str]
1924         '''
1925         self.charm_urls = charm_urls
1926
1927
1928
1929 class ClaimLeadershipBulkParams(Type):
1930     _toSchema = {'params': 'params'}
1931     _toPy = {'params': 'params'}
1932     def __init__(self, params=None, **unknown_fields):
1933         '''
1934         params : typing.Sequence[~ClaimLeadershipParams]
1935         '''
1936         self.params = [ClaimLeadershipParams.from_json(o) for o in params or []]
1937
1938
1939
1940 class ClaimLeadershipBulkResults(Type):
1941     _toSchema = {'results': 'results'}
1942     _toPy = {'results': 'results'}
1943     def __init__(self, results=None, **unknown_fields):
1944         '''
1945         results : typing.Sequence[~ErrorResult]
1946         '''
1947         self.results = [ErrorResult.from_json(o) for o in results or []]
1948
1949
1950
1951 class ClaimLeadershipParams(Type):
1952     _toSchema = {'application_tag': 'application-tag', 'duration': 'duration', 'unit_tag': 'unit-tag'}
1953     _toPy = {'application-tag': 'application_tag', 'duration': 'duration', 'unit-tag': 'unit_tag'}
1954     def __init__(self, application_tag=None, duration=None, unit_tag=None, **unknown_fields):
1955         '''
1956         application_tag : str
1957         duration : float
1958         unit_tag : str
1959         '''
1960         self.application_tag = application_tag
1961         self.duration = duration
1962         self.unit_tag = unit_tag
1963
1964
1965
1966 class Cloud(Type):
1967     _toSchema = {'auth_types': 'auth-types', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'regions': 'regions', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
1968     _toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
1969     def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None, **unknown_fields):
1970         '''
1971         auth_types : typing.Sequence[str]
1972         endpoint : str
1973         identity_endpoint : str
1974         regions : typing.Sequence[~CloudRegion]
1975         storage_endpoint : str
1976         type_ : str
1977         '''
1978         self.auth_types = auth_types
1979         self.endpoint = endpoint
1980         self.identity_endpoint = identity_endpoint
1981         self.regions = [CloudRegion.from_json(o) for o in regions or []]
1982         self.storage_endpoint = storage_endpoint
1983         self.type_ = type_
1984
1985
1986
1987 class CloudCredential(Type):
1988     _toSchema = {'attrs': 'attrs', 'auth_type': 'auth-type', 'redacted': 'redacted'}
1989     _toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'redacted': 'redacted'}
1990     def __init__(self, attrs=None, auth_type=None, redacted=None, **unknown_fields):
1991         '''
1992         attrs : typing.Mapping[str, str]
1993         auth_type : str
1994         redacted : typing.Sequence[str]
1995         '''
1996         self.attrs = attrs
1997         self.auth_type = auth_type
1998         self.redacted = redacted
1999
2000
2001
2002 class CloudCredentialArg(Type):
2003     _toSchema = {'cloud_name': 'cloud-name', 'credential_name': 'credential-name'}
2004     _toPy = {'cloud-name': 'cloud_name', 'credential-name': 'credential_name'}
2005     def __init__(self, cloud_name=None, credential_name=None, **unknown_fields):
2006         '''
2007         cloud_name : str
2008         credential_name : str
2009         '''
2010         self.cloud_name = cloud_name
2011         self.credential_name = credential_name
2012
2013
2014
2015 class CloudCredentialArgs(Type):
2016     _toSchema = {'credentials': 'credentials', 'include_secrets': 'include-secrets'}
2017     _toPy = {'credentials': 'credentials', 'include-secrets': 'include_secrets'}
2018     def __init__(self, credentials=None, include_secrets=None, **unknown_fields):
2019         '''
2020         credentials : typing.Sequence[~CloudCredentialArg]
2021         include_secrets : bool
2022         '''
2023         self.credentials = [CloudCredentialArg.from_json(o) for o in credentials or []]
2024         self.include_secrets = include_secrets
2025
2026
2027
2028 class CloudCredentialResult(Type):
2029     _toSchema = {'error': 'error', 'result': 'result'}
2030     _toPy = {'error': 'error', 'result': 'result'}
2031     def __init__(self, error=None, result=None, **unknown_fields):
2032         '''
2033         error : Error
2034         result : CloudCredential
2035         '''
2036         self.error = Error.from_json(error) if error else None
2037         self.result = CloudCredential.from_json(result) if result else None
2038
2039
2040
2041 class CloudCredentialResults(Type):
2042     _toSchema = {'results': 'results'}
2043     _toPy = {'results': 'results'}
2044     def __init__(self, results=None, **unknown_fields):
2045         '''
2046         results : typing.Sequence[~CloudCredentialResult]
2047         '''
2048         self.results = [CloudCredentialResult.from_json(o) for o in results or []]
2049
2050
2051
2052 class CloudDetails(Type):
2053     _toSchema = {'auth_types': 'auth-types', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'regions': 'regions', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
2054     _toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
2055     def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None, **unknown_fields):
2056         '''
2057         auth_types : typing.Sequence[str]
2058         endpoint : str
2059         identity_endpoint : str
2060         regions : typing.Sequence[~CloudRegion]
2061         storage_endpoint : str
2062         type_ : str
2063         '''
2064         self.auth_types = auth_types
2065         self.endpoint = endpoint
2066         self.identity_endpoint = identity_endpoint
2067         self.regions = [CloudRegion.from_json(o) for o in regions or []]
2068         self.storage_endpoint = storage_endpoint
2069         self.type_ = type_
2070
2071
2072
2073 class CloudImageMetadata(Type):
2074     _toSchema = {'arch': 'arch', 'image_id': 'image-id', 'priority': 'priority', 'region': 'region', 'root_storage_size': 'root-storage-size', 'root_storage_type': 'root-storage-type', 'series': 'series', 'source': 'source', 'stream': 'stream', 'version': 'version', 'virt_type': 'virt-type'}
2075     _toPy = {'arch': 'arch', 'image-id': 'image_id', 'priority': 'priority', 'region': 'region', 'root-storage-size': 'root_storage_size', 'root-storage-type': 'root_storage_type', 'series': 'series', 'source': 'source', 'stream': 'stream', 'version': 'version', 'virt-type': 'virt_type'}
2076     def __init__(self, arch=None, image_id=None, priority=None, region=None, root_storage_size=None, root_storage_type=None, series=None, source=None, stream=None, version=None, virt_type=None, **unknown_fields):
2077         '''
2078         arch : str
2079         image_id : str
2080         priority : int
2081         region : str
2082         root_storage_size : int
2083         root_storage_type : str
2084         series : str
2085         source : str
2086         stream : str
2087         version : str
2088         virt_type : str
2089         '''
2090         self.arch = arch
2091         self.image_id = image_id
2092         self.priority = priority
2093         self.region = region
2094         self.root_storage_size = root_storage_size
2095         self.root_storage_type = root_storage_type
2096         self.series = series
2097         self.source = source
2098         self.stream = stream
2099         self.version = version
2100         self.virt_type = virt_type
2101
2102
2103
2104 class CloudImageMetadataList(Type):
2105     _toSchema = {'metadata': 'metadata'}
2106     _toPy = {'metadata': 'metadata'}
2107     def __init__(self, metadata=None, **unknown_fields):
2108         '''
2109         metadata : typing.Sequence[~CloudImageMetadata]
2110         '''
2111         self.metadata = [CloudImageMetadata.from_json(o) for o in metadata or []]
2112
2113
2114
2115 class CloudInfo(Type):
2116     _toSchema = {'clouddetails': 'CloudDetails', 'users': 'users'}
2117     _toPy = {'CloudDetails': 'clouddetails', 'users': 'users'}
2118     def __init__(self, clouddetails=None, users=None, **unknown_fields):
2119         '''
2120         clouddetails : CloudDetails
2121         users : typing.Sequence[~CloudUserInfo]
2122         '''
2123         self.clouddetails = CloudDetails.from_json(clouddetails) if clouddetails else None
2124         self.users = [CloudUserInfo.from_json(o) for o in users or []]
2125
2126
2127
2128 class CloudInfoResult(Type):
2129     _toSchema = {'error': 'error', 'result': 'result'}
2130     _toPy = {'error': 'error', 'result': 'result'}
2131     def __init__(self, error=None, result=None, **unknown_fields):
2132         '''
2133         error : Error
2134         result : CloudInfo
2135         '''
2136         self.error = Error.from_json(error) if error else None
2137         self.result = CloudInfo.from_json(result) if result else None
2138
2139
2140
2141 class CloudInfoResults(Type):
2142     _toSchema = {'results': 'results'}
2143     _toPy = {'results': 'results'}
2144     def __init__(self, results=None, **unknown_fields):
2145         '''
2146         results : typing.Sequence[~CloudInfoResult]
2147         '''
2148         self.results = [CloudInfoResult.from_json(o) for o in results or []]
2149
2150
2151
2152 class CloudInstanceTypesConstraint(Type):
2153     _toSchema = {'cloud_tag': 'cloud-tag', 'constraints': 'constraints', 'region': 'region'}
2154     _toPy = {'cloud-tag': 'cloud_tag', 'constraints': 'constraints', 'region': 'region'}
2155     def __init__(self, cloud_tag=None, constraints=None, region=None, **unknown_fields):
2156         '''
2157         cloud_tag : str
2158         constraints : Value
2159         region : str
2160         '''
2161         self.cloud_tag = cloud_tag
2162         self.constraints = Value.from_json(constraints) if constraints else None
2163         self.region = region
2164
2165
2166
2167 class CloudInstanceTypesConstraints(Type):
2168     _toSchema = {'constraints': 'constraints'}
2169     _toPy = {'constraints': 'constraints'}
2170     def __init__(self, constraints=None, **unknown_fields):
2171         '''
2172         constraints : typing.Sequence[~CloudInstanceTypesConstraint]
2173         '''
2174         self.constraints = [CloudInstanceTypesConstraint.from_json(o) for o in constraints or []]
2175
2176
2177
2178 class CloudRegion(Type):
2179     _toSchema = {'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'name': 'name', 'storage_endpoint': 'storage-endpoint'}
2180     _toPy = {'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'name': 'name', 'storage-endpoint': 'storage_endpoint'}
2181     def __init__(self, endpoint=None, identity_endpoint=None, name=None, storage_endpoint=None, **unknown_fields):
2182         '''
2183         endpoint : str
2184         identity_endpoint : str
2185         name : str
2186         storage_endpoint : str
2187         '''
2188         self.endpoint = endpoint
2189         self.identity_endpoint = identity_endpoint
2190         self.name = name
2191         self.storage_endpoint = storage_endpoint
2192
2193
2194
2195 class CloudResult(Type):
2196     _toSchema = {'cloud': 'cloud', 'error': 'error'}
2197     _toPy = {'cloud': 'cloud', 'error': 'error'}
2198     def __init__(self, cloud=None, error=None, **unknown_fields):
2199         '''
2200         cloud : Cloud
2201         error : Error
2202         '''
2203         self.cloud = Cloud.from_json(cloud) if cloud else None
2204         self.error = Error.from_json(error) if error else None
2205
2206
2207
2208 class CloudResults(Type):
2209     _toSchema = {'results': 'results'}
2210     _toPy = {'results': 'results'}
2211     def __init__(self, results=None, **unknown_fields):
2212         '''
2213         results : typing.Sequence[~CloudResult]
2214         '''
2215         self.results = [CloudResult.from_json(o) for o in results or []]
2216
2217
2218
2219 class CloudSpec(Type):
2220     _toSchema = {'credential': 'credential', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'name': 'name', 'region': 'region', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
2221     _toPy = {'credential': 'credential', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'name': 'name', 'region': 'region', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
2222     def __init__(self, credential=None, endpoint=None, identity_endpoint=None, name=None, region=None, storage_endpoint=None, type_=None, **unknown_fields):
2223         '''
2224         credential : CloudCredential
2225         endpoint : str
2226         identity_endpoint : str
2227         name : str
2228         region : str
2229         storage_endpoint : str
2230         type_ : str
2231         '''
2232         self.credential = CloudCredential.from_json(credential) if credential else None
2233         self.endpoint = endpoint
2234         self.identity_endpoint = identity_endpoint
2235         self.name = name
2236         self.region = region
2237         self.storage_endpoint = storage_endpoint
2238         self.type_ = type_
2239
2240
2241
2242 class CloudSpecResult(Type):
2243     _toSchema = {'error': 'error', 'result': 'result'}
2244     _toPy = {'error': 'error', 'result': 'result'}
2245     def __init__(self, error=None, result=None, **unknown_fields):
2246         '''
2247         error : Error
2248         result : CloudSpec
2249         '''
2250         self.error = Error.from_json(error) if error else None
2251         self.result = CloudSpec.from_json(result) if result else None
2252
2253
2254
2255 class CloudSpecResults(Type):
2256     _toSchema = {'results': 'results'}
2257     _toPy = {'results': 'results'}
2258     def __init__(self, results=None, **unknown_fields):
2259         '''
2260         results : typing.Sequence[~CloudSpecResult]
2261         '''
2262         self.results = [CloudSpecResult.from_json(o) for o in results or []]
2263
2264
2265
2266 class CloudUserInfo(Type):
2267     _toSchema = {'access': 'access', 'display_name': 'display-name', 'user': 'user'}
2268     _toPy = {'access': 'access', 'display-name': 'display_name', 'user': 'user'}
2269     def __init__(self, access=None, display_name=None, user=None, **unknown_fields):
2270         '''
2271         access : str
2272         display_name : str
2273         user : str
2274         '''
2275         self.access = access
2276         self.display_name = display_name
2277         self.user = user
2278
2279
2280
2281 class CloudsResult(Type):
2282     _toSchema = {'clouds': 'clouds'}
2283     _toPy = {'clouds': 'clouds'}
2284     def __init__(self, clouds=None, **unknown_fields):
2285         '''
2286         clouds : typing.Mapping[str, ~Cloud]
2287         '''
2288         self.clouds = clouds
2289
2290
2291
2292 class ConfigResult(Type):
2293     _toSchema = {'config': 'config', 'error': 'error'}
2294     _toPy = {'config': 'config', 'error': 'error'}
2295     def __init__(self, config=None, error=None, **unknown_fields):
2296         '''
2297         config : typing.Mapping[str, typing.Any]
2298         error : Error
2299         '''
2300         self.config = config
2301         self.error = Error.from_json(error) if error else None
2302
2303
2304
2305 class ConfigSettingsResult(Type):
2306     _toSchema = {'error': 'error', 'settings': 'settings'}
2307     _toPy = {'error': 'error', 'settings': 'settings'}
2308     def __init__(self, error=None, settings=None, **unknown_fields):
2309         '''
2310         error : Error
2311         settings : typing.Mapping[str, typing.Any]
2312         '''
2313         self.error = Error.from_json(error) if error else None
2314         self.settings = settings
2315
2316
2317
2318 class ConfigSettingsResults(Type):
2319     _toSchema = {'results': 'results'}
2320     _toPy = {'results': 'results'}
2321     def __init__(self, results=None, **unknown_fields):
2322         '''
2323         results : typing.Sequence[~ConfigSettingsResult]
2324         '''
2325         self.results = [ConfigSettingsResult.from_json(o) for o in results or []]
2326
2327
2328
2329 class ConfigValue(Type):
2330     _toSchema = {'source': 'source', 'value': 'value'}
2331     _toPy = {'source': 'source', 'value': 'value'}
2332     def __init__(self, source=None, value=None, **unknown_fields):
2333         '''
2334         source : str
2335         value : typing.Mapping[str, typing.Any]
2336         '''
2337         self.source = source
2338         self.value = value
2339
2340
2341
2342 class Constraints(Type):
2343     _toSchema = {'count': 'Count', 'pool': 'Pool', 'size': 'Size'}
2344     _toPy = {'Count': 'count', 'Pool': 'pool', 'Size': 'size'}
2345     def __init__(self, count=None, pool=None, size=None, **unknown_fields):
2346         '''
2347         count : int
2348         pool : str
2349         size : int
2350         '''
2351         self.count = count
2352         self.pool = pool
2353         self.size = size
2354
2355
2356
2357 class ConstraintsResult(Type):
2358     _toSchema = {'constraints': 'constraints', 'error': 'error'}
2359     _toPy = {'constraints': 'constraints', 'error': 'error'}
2360     def __init__(self, constraints=None, error=None, **unknown_fields):
2361         '''
2362         constraints : Value
2363         error : Error
2364         '''
2365         self.constraints = Value.from_json(constraints) if constraints else None
2366         self.error = Error.from_json(error) if error else None
2367
2368
2369
2370 class ConstraintsResults(Type):
2371     _toSchema = {'results': 'results'}
2372     _toPy = {'results': 'results'}
2373     def __init__(self, results=None, **unknown_fields):
2374         '''
2375         results : typing.Sequence[~ConstraintsResult]
2376         '''
2377         self.results = [ConstraintsResult.from_json(o) for o in results or []]
2378
2379
2380
2381 class ConsumeApplicationArg(Type):
2382     _toSchema = {'application_alias': 'application-alias', 'application_url': 'application-url'}
2383     _toPy = {'application-alias': 'application_alias', 'application-url': 'application_url'}
2384     def __init__(self, application_alias=None, application_url=None, **unknown_fields):
2385         '''
2386         application_alias : str
2387         application_url : str
2388         '''
2389         self.application_alias = application_alias
2390         self.application_url = application_url
2391
2392
2393
2394 class ConsumeApplicationArgs(Type):
2395     _toSchema = {'args': 'args'}
2396     _toPy = {'args': 'args'}
2397     def __init__(self, args=None, **unknown_fields):
2398         '''
2399         args : typing.Sequence[~ConsumeApplicationArg]
2400         '''
2401         self.args = [ConsumeApplicationArg.from_json(o) for o in args or []]
2402
2403
2404
2405 class ConsumeApplicationResult(Type):
2406     _toSchema = {'error': 'error', 'local_name': 'local-name'}
2407     _toPy = {'error': 'error', 'local-name': 'local_name'}
2408     def __init__(self, error=None, local_name=None, **unknown_fields):
2409         '''
2410         error : Error
2411         local_name : str
2412         '''
2413         self.error = Error.from_json(error) if error else None
2414         self.local_name = local_name
2415
2416
2417
2418 class ConsumeApplicationResults(Type):
2419     _toSchema = {'results': 'results'}
2420     _toPy = {'results': 'results'}
2421     def __init__(self, results=None, **unknown_fields):
2422         '''
2423         results : typing.Sequence[~ConsumeApplicationResult]
2424         '''
2425         self.results = [ConsumeApplicationResult.from_json(o) for o in results or []]
2426
2427
2428
2429 class ConsumeOfferDetails(Type):
2430     _toSchema = {'external_controller': 'external-controller', 'macaroon': 'macaroon', 'offer': 'offer'}
2431     _toPy = {'external-controller': 'external_controller', 'macaroon': 'macaroon', 'offer': 'offer'}
2432     def __init__(self, external_controller=None, macaroon=None, offer=None, **unknown_fields):
2433         '''
2434         external_controller : ExternalControllerInfo
2435         macaroon : Macaroon
2436         offer : ApplicationOfferDetails
2437         '''
2438         self.external_controller = ExternalControllerInfo.from_json(external_controller) if external_controller else None
2439         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
2440         self.offer = ApplicationOfferDetails.from_json(offer) if offer else None
2441
2442
2443
2444 class ConsumeOfferDetailsResult(Type):
2445     _toSchema = {'consumeofferdetails': 'ConsumeOfferDetails', 'error': 'error'}
2446     _toPy = {'ConsumeOfferDetails': 'consumeofferdetails', 'error': 'error'}
2447     def __init__(self, consumeofferdetails=None, error=None, **unknown_fields):
2448         '''
2449         consumeofferdetails : ConsumeOfferDetails
2450         error : Error
2451         '''
2452         self.consumeofferdetails = ConsumeOfferDetails.from_json(consumeofferdetails) if consumeofferdetails else None
2453         self.error = Error.from_json(error) if error else None
2454
2455
2456
2457 class ConsumeOfferDetailsResults(Type):
2458     _toSchema = {'results': 'results'}
2459     _toPy = {'results': 'results'}
2460     def __init__(self, results=None, **unknown_fields):
2461         '''
2462         results : typing.Sequence[~ConsumeOfferDetailsResult]
2463         '''
2464         self.results = [ConsumeOfferDetailsResult.from_json(o) for o in results or []]
2465
2466
2467
2468 class ContainerConfig(Type):
2469     _toSchema = {'apt_mirror': 'apt-mirror', 'apt_proxy': 'apt-proxy', 'authorized_keys': 'authorized-keys', 'provider_type': 'provider-type', 'proxy': 'proxy', 'ssl_hostname_verification': 'ssl-hostname-verification', 'updatebehavior': 'UpdateBehavior'}
2470     _toPy = {'UpdateBehavior': 'updatebehavior', 'apt-mirror': 'apt_mirror', 'apt-proxy': 'apt_proxy', 'authorized-keys': 'authorized_keys', 'provider-type': 'provider_type', 'proxy': 'proxy', 'ssl-hostname-verification': 'ssl_hostname_verification'}
2471     def __init__(self, updatebehavior=None, apt_mirror=None, apt_proxy=None, authorized_keys=None, provider_type=None, proxy=None, ssl_hostname_verification=None, **unknown_fields):
2472         '''
2473         updatebehavior : UpdateBehavior
2474         apt_mirror : str
2475         apt_proxy : Settings
2476         authorized_keys : str
2477         provider_type : str
2478         proxy : Settings
2479         ssl_hostname_verification : bool
2480         '''
2481         self.updatebehavior = UpdateBehavior.from_json(updatebehavior) if updatebehavior else None
2482         self.apt_mirror = apt_mirror
2483         self.apt_proxy = Settings.from_json(apt_proxy) if apt_proxy else None
2484         self.authorized_keys = authorized_keys
2485         self.provider_type = provider_type
2486         self.proxy = Settings.from_json(proxy) if proxy else None
2487         self.ssl_hostname_verification = ssl_hostname_verification
2488
2489
2490
2491 class ContainerLXDProfile(Type):
2492     _toSchema = {'name': 'name', 'profile': 'profile'}
2493     _toPy = {'name': 'name', 'profile': 'profile'}
2494     def __init__(self, name=None, profile=None, **unknown_fields):
2495         '''
2496         name : str
2497         profile : CharmLXDProfile
2498         '''
2499         self.name = name
2500         self.profile = CharmLXDProfile.from_json(profile) if profile else None
2501
2502
2503
2504 class ContainerManagerConfig(Type):
2505     _toSchema = {'config': 'config'}
2506     _toPy = {'config': 'config'}
2507     def __init__(self, config=None, **unknown_fields):
2508         '''
2509         config : typing.Mapping[str, str]
2510         '''
2511         self.config = config
2512
2513
2514
2515 class ContainerManagerConfigParams(Type):
2516     _toSchema = {'type_': 'type'}
2517     _toPy = {'type': 'type_'}
2518     def __init__(self, type_=None, **unknown_fields):
2519         '''
2520         type_ : str
2521         '''
2522         self.type_ = type_
2523
2524
2525
2526 class ContainerProfileResult(Type):
2527     _toSchema = {'error': 'error', 'lxd_profiles': 'lxd-profiles'}
2528     _toPy = {'error': 'error', 'lxd-profiles': 'lxd_profiles'}
2529     def __init__(self, error=None, lxd_profiles=None, **unknown_fields):
2530         '''
2531         error : Error
2532         lxd_profiles : typing.Sequence[~ContainerLXDProfile]
2533         '''
2534         self.error = Error.from_json(error) if error else None
2535         self.lxd_profiles = [ContainerLXDProfile.from_json(o) for o in lxd_profiles or []]
2536
2537
2538
2539 class ContainerProfileResults(Type):
2540     _toSchema = {'results': 'results'}
2541     _toPy = {'results': 'results'}
2542     def __init__(self, results=None, **unknown_fields):
2543         '''
2544         results : typing.Sequence[~ContainerProfileResult]
2545         '''
2546         self.results = [ContainerProfileResult.from_json(o) for o in results or []]
2547
2548
2549
2550 class ControllerAPIInfoResult(Type):
2551     _toSchema = {'addresses': 'addresses', 'cacert': 'cacert', 'error': 'error'}
2552     _toPy = {'addresses': 'addresses', 'cacert': 'cacert', 'error': 'error'}
2553     def __init__(self, addresses=None, cacert=None, error=None, **unknown_fields):
2554         '''
2555         addresses : typing.Sequence[str]
2556         cacert : str
2557         error : Error
2558         '''
2559         self.addresses = addresses
2560         self.cacert = cacert
2561         self.error = Error.from_json(error) if error else None
2562
2563
2564
2565 class ControllerAPIInfoResults(Type):
2566     _toSchema = {'results': 'results'}
2567     _toPy = {'results': 'results'}
2568     def __init__(self, results=None, **unknown_fields):
2569         '''
2570         results : typing.Sequence[~ControllerAPIInfoResult]
2571         '''
2572         self.results = [ControllerAPIInfoResult.from_json(o) for o in results or []]
2573
2574
2575
2576 class ControllerConfigResult(Type):
2577     _toSchema = {'config': 'config'}
2578     _toPy = {'config': 'config'}
2579     def __init__(self, config=None, **unknown_fields):
2580         '''
2581         config : typing.Mapping[str, typing.Any]
2582         '''
2583         self.config = config
2584
2585
2586
2587 class ControllerConfigSet(Type):
2588     _toSchema = {'config': 'config'}
2589     _toPy = {'config': 'config'}
2590     def __init__(self, config=None, **unknown_fields):
2591         '''
2592         config : typing.Mapping[str, typing.Any]
2593         '''
2594         self.config = config
2595
2596
2597
2598 class ControllerCredentialInfo(Type):
2599     _toSchema = {'content': 'content', 'models': 'models'}
2600     _toPy = {'content': 'content', 'models': 'models'}
2601     def __init__(self, content=None, models=None, **unknown_fields):
2602         '''
2603         content : CredentialContent
2604         models : typing.Sequence[~ModelAccess]
2605         '''
2606         self.content = CredentialContent.from_json(content) if content else None
2607         self.models = [ModelAccess.from_json(o) for o in models or []]
2608
2609
2610
2611 class ControllersChangeResult(Type):
2612     _toSchema = {'error': 'error', 'result': 'result'}
2613     _toPy = {'error': 'error', 'result': 'result'}
2614     def __init__(self, error=None, result=None, **unknown_fields):
2615         '''
2616         error : Error
2617         result : ControllersChanges
2618         '''
2619         self.error = Error.from_json(error) if error else None
2620         self.result = ControllersChanges.from_json(result) if result else None
2621
2622
2623
2624 class ControllersChangeResults(Type):
2625     _toSchema = {'results': 'results'}
2626     _toPy = {'results': 'results'}
2627     def __init__(self, results=None, **unknown_fields):
2628         '''
2629         results : typing.Sequence[~ControllersChangeResult]
2630         '''
2631         self.results = [ControllersChangeResult.from_json(o) for o in results or []]
2632
2633
2634
2635 class ControllersChanges(Type):
2636     _toSchema = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
2637     _toPy = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
2638     def __init__(self, added=None, converted=None, demoted=None, maintained=None, promoted=None, removed=None, **unknown_fields):
2639         '''
2640         added : typing.Sequence[str]
2641         converted : typing.Sequence[str]
2642         demoted : typing.Sequence[str]
2643         maintained : typing.Sequence[str]
2644         promoted : typing.Sequence[str]
2645         removed : typing.Sequence[str]
2646         '''
2647         self.added = added
2648         self.converted = converted
2649         self.demoted = demoted
2650         self.maintained = maintained
2651         self.promoted = promoted
2652         self.removed = removed
2653
2654
2655
2656 class ControllersSpec(Type):
2657     _toSchema = {'constraints': 'constraints', 'num_controllers': 'num-controllers', 'placement': 'placement', 'series': 'series'}
2658     _toPy = {'constraints': 'constraints', 'num-controllers': 'num_controllers', 'placement': 'placement', 'series': 'series'}
2659     def __init__(self, constraints=None, num_controllers=None, placement=None, series=None, **unknown_fields):
2660         '''
2661         constraints : Value
2662         num_controllers : int
2663         placement : typing.Sequence[str]
2664         series : str
2665         '''
2666         self.constraints = Value.from_json(constraints) if constraints else None
2667         self.num_controllers = num_controllers
2668         self.placement = placement
2669         self.series = series
2670
2671
2672
2673 class ControllersSpecs(Type):
2674     _toSchema = {'specs': 'specs'}
2675     _toPy = {'specs': 'specs'}
2676     def __init__(self, specs=None, **unknown_fields):
2677         '''
2678         specs : typing.Sequence[~ControllersSpec]
2679         '''
2680         self.specs = [ControllersSpec.from_json(o) for o in specs or []]
2681
2682
2683
2684 class CreateSpaceParams(Type):
2685     _toSchema = {'provider_id': 'provider-id', 'public': 'public', 'space_tag': 'space-tag', 'subnet_tags': 'subnet-tags'}
2686     _toPy = {'provider-id': 'provider_id', 'public': 'public', 'space-tag': 'space_tag', 'subnet-tags': 'subnet_tags'}
2687     def __init__(self, provider_id=None, public=None, space_tag=None, subnet_tags=None, **unknown_fields):
2688         '''
2689         provider_id : str
2690         public : bool
2691         space_tag : str
2692         subnet_tags : typing.Sequence[str]
2693         '''
2694         self.provider_id = provider_id
2695         self.public = public
2696         self.space_tag = space_tag
2697         self.subnet_tags = subnet_tags
2698
2699
2700
2701 class CreateSpacesParams(Type):
2702     _toSchema = {'spaces': 'spaces'}
2703     _toPy = {'spaces': 'spaces'}
2704     def __init__(self, spaces=None, **unknown_fields):
2705         '''
2706         spaces : typing.Sequence[~CreateSpaceParams]
2707         '''
2708         self.spaces = [CreateSpaceParams.from_json(o) for o in spaces or []]
2709
2710
2711
2712 class CredentialContent(Type):
2713     _toSchema = {'attrs': 'attrs', 'auth_type': 'auth-type', 'cloud': 'cloud', 'name': 'name'}
2714     _toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'cloud': 'cloud', 'name': 'name'}
2715     def __init__(self, attrs=None, auth_type=None, cloud=None, name=None, **unknown_fields):
2716         '''
2717         attrs : typing.Mapping[str, str]
2718         auth_type : str
2719         cloud : str
2720         name : str
2721         '''
2722         self.attrs = attrs
2723         self.auth_type = auth_type
2724         self.cloud = cloud
2725         self.name = name
2726
2727
2728
2729 class CredentialContentResult(Type):
2730     _toSchema = {'error': 'error', 'result': 'result'}
2731     _toPy = {'error': 'error', 'result': 'result'}
2732     def __init__(self, error=None, result=None, **unknown_fields):
2733         '''
2734         error : Error
2735         result : ControllerCredentialInfo
2736         '''
2737         self.error = Error.from_json(error) if error else None
2738         self.result = ControllerCredentialInfo.from_json(result) if result else None
2739
2740
2741
2742 class CredentialContentResults(Type):
2743     _toSchema = {'results': 'results'}
2744     _toPy = {'results': 'results'}
2745     def __init__(self, results=None, **unknown_fields):
2746         '''
2747         results : typing.Sequence[~CredentialContentResult]
2748         '''
2749         self.results = [CredentialContentResult.from_json(o) for o in results or []]
2750
2751
2752
2753 class Delta(Type):
2754     _toSchema = {'entity': 'entity', 'removed': 'removed'}
2755     _toPy = {'entity': 'entity', 'removed': 'removed'}
2756     def __init__(self, entity=None, removed=None, **unknown_fields):
2757         '''
2758         entity : typing.Mapping[str, typing.Any]
2759         removed : bool
2760         '''
2761         self.entity = entity
2762         self.removed = removed
2763
2764
2765
2766 class DeployerConnectionValues(Type):
2767     _toSchema = {'api_addresses': 'api-addresses', 'state_addresses': 'state-addresses'}
2768     _toPy = {'api-addresses': 'api_addresses', 'state-addresses': 'state_addresses'}
2769     def __init__(self, api_addresses=None, state_addresses=None, **unknown_fields):
2770         '''
2771         api_addresses : typing.Sequence[str]
2772         state_addresses : typing.Sequence[str]
2773         '''
2774         self.api_addresses = api_addresses
2775         self.state_addresses = state_addresses
2776
2777
2778
2779 class DestroyApplicationInfo(Type):
2780     _toSchema = {'destroyed_storage': 'destroyed-storage', 'destroyed_units': 'destroyed-units', 'detached_storage': 'detached-storage'}
2781     _toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
2782     def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None, **unknown_fields):
2783         '''
2784         destroyed_storage : typing.Sequence[~Entity]
2785         destroyed_units : typing.Sequence[~Entity]
2786         detached_storage : typing.Sequence[~Entity]
2787         '''
2788         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
2789         self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
2790         self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
2791
2792
2793
2794 class DestroyApplicationOffers(Type):
2795     _toSchema = {'force': 'force', 'offer_urls': 'offer-urls'}
2796     _toPy = {'force': 'force', 'offer-urls': 'offer_urls'}
2797     def __init__(self, force=None, offer_urls=None, **unknown_fields):
2798         '''
2799         force : bool
2800         offer_urls : typing.Sequence[str]
2801         '''
2802         self.force = force
2803         self.offer_urls = offer_urls
2804
2805
2806
2807 class DestroyApplicationParams(Type):
2808     _toSchema = {'application_tag': 'application-tag', 'destroy_storage': 'destroy-storage'}
2809     _toPy = {'application-tag': 'application_tag', 'destroy-storage': 'destroy_storage'}
2810     def __init__(self, application_tag=None, destroy_storage=None, **unknown_fields):
2811         '''
2812         application_tag : str
2813         destroy_storage : bool
2814         '''
2815         self.application_tag = application_tag
2816         self.destroy_storage = destroy_storage
2817
2818
2819
2820 class DestroyApplicationResult(Type):
2821     _toSchema = {'error': 'error', 'info': 'info'}
2822     _toPy = {'error': 'error', 'info': 'info'}
2823     def __init__(self, error=None, info=None, **unknown_fields):
2824         '''
2825         error : Error
2826         info : DestroyApplicationInfo
2827         '''
2828         self.error = Error.from_json(error) if error else None
2829         self.info = DestroyApplicationInfo.from_json(info) if info else None
2830
2831
2832
2833 class DestroyApplicationResults(Type):
2834     _toSchema = {'results': 'results'}
2835     _toPy = {'results': 'results'}
2836     def __init__(self, results=None, **unknown_fields):
2837         '''
2838         results : typing.Sequence[~DestroyApplicationResult]
2839         '''
2840         self.results = [DestroyApplicationResult.from_json(o) for o in results or []]
2841
2842
2843
2844 class DestroyApplicationUnits(Type):
2845     _toSchema = {'unit_names': 'unit-names'}
2846     _toPy = {'unit-names': 'unit_names'}
2847     def __init__(self, unit_names=None, **unknown_fields):
2848         '''
2849         unit_names : typing.Sequence[str]
2850         '''
2851         self.unit_names = unit_names
2852
2853
2854
2855 class DestroyApplicationsParams(Type):
2856     _toSchema = {'applications': 'applications'}
2857     _toPy = {'applications': 'applications'}
2858     def __init__(self, applications=None, **unknown_fields):
2859         '''
2860         applications : typing.Sequence[~DestroyApplicationParams]
2861         '''
2862         self.applications = [DestroyApplicationParams.from_json(o) for o in applications or []]
2863
2864
2865
2866 class DestroyConsumedApplicationParams(Type):
2867     _toSchema = {'application_tag': 'application-tag'}
2868     _toPy = {'application-tag': 'application_tag'}
2869     def __init__(self, application_tag=None, **unknown_fields):
2870         '''
2871         application_tag : str
2872         '''
2873         self.application_tag = application_tag
2874
2875
2876
2877 class DestroyConsumedApplicationsParams(Type):
2878     _toSchema = {'applications': 'applications'}
2879     _toPy = {'applications': 'applications'}
2880     def __init__(self, applications=None, **unknown_fields):
2881         '''
2882         applications : typing.Sequence[~DestroyConsumedApplicationParams]
2883         '''
2884         self.applications = [DestroyConsumedApplicationParams.from_json(o) for o in applications or []]
2885
2886
2887
2888 class DestroyControllerArgs(Type):
2889     _toSchema = {'destroy_models': 'destroy-models'}
2890     _toPy = {'destroy-models': 'destroy_models'}
2891     def __init__(self, destroy_models=None, **unknown_fields):
2892         '''
2893         destroy_models : bool
2894         '''
2895         self.destroy_models = destroy_models
2896
2897
2898
2899 class DestroyMachineInfo(Type):
2900     _toSchema = {'destroyed_storage': 'destroyed-storage', 'destroyed_units': 'destroyed-units', 'detached_storage': 'detached-storage'}
2901     _toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
2902     def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None, **unknown_fields):
2903         '''
2904         destroyed_storage : typing.Sequence[~Entity]
2905         destroyed_units : typing.Sequence[~Entity]
2906         detached_storage : typing.Sequence[~Entity]
2907         '''
2908         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
2909         self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
2910         self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
2911
2912
2913
2914 class DestroyMachineResult(Type):
2915     _toSchema = {'error': 'error', 'info': 'info'}
2916     _toPy = {'error': 'error', 'info': 'info'}
2917     def __init__(self, error=None, info=None, **unknown_fields):
2918         '''
2919         error : Error
2920         info : DestroyMachineInfo
2921         '''
2922         self.error = Error.from_json(error) if error else None
2923         self.info = DestroyMachineInfo.from_json(info) if info else None
2924
2925
2926
2927 class DestroyMachineResults(Type):
2928     _toSchema = {'results': 'results'}
2929     _toPy = {'results': 'results'}
2930     def __init__(self, results=None, **unknown_fields):
2931         '''
2932         results : typing.Sequence[~DestroyMachineResult]
2933         '''
2934         self.results = [DestroyMachineResult.from_json(o) for o in results or []]
2935
2936
2937
2938 class DestroyMachines(Type):
2939     _toSchema = {'force': 'force', 'machine_names': 'machine-names'}
2940     _toPy = {'force': 'force', 'machine-names': 'machine_names'}
2941     def __init__(self, force=None, machine_names=None, **unknown_fields):
2942         '''
2943         force : bool
2944         machine_names : typing.Sequence[str]
2945         '''
2946         self.force = force
2947         self.machine_names = machine_names
2948
2949
2950
2951 class DestroyMachinesParams(Type):
2952     _toSchema = {'force': 'force', 'keep': 'keep', 'machine_tags': 'machine-tags'}
2953     _toPy = {'force': 'force', 'keep': 'keep', 'machine-tags': 'machine_tags'}
2954     def __init__(self, force=None, keep=None, machine_tags=None, **unknown_fields):
2955         '''
2956         force : bool
2957         keep : bool
2958         machine_tags : typing.Sequence[str]
2959         '''
2960         self.force = force
2961         self.keep = keep
2962         self.machine_tags = machine_tags
2963
2964
2965
2966 class DestroyModelParams(Type):
2967     _toSchema = {'destroy_storage': 'destroy-storage', 'model_tag': 'model-tag'}
2968     _toPy = {'destroy-storage': 'destroy_storage', 'model-tag': 'model_tag'}
2969     def __init__(self, destroy_storage=None, model_tag=None, **unknown_fields):
2970         '''
2971         destroy_storage : bool
2972         model_tag : str
2973         '''
2974         self.destroy_storage = destroy_storage
2975         self.model_tag = model_tag
2976
2977
2978
2979 class DestroyModelsParams(Type):
2980     _toSchema = {'models': 'models'}
2981     _toPy = {'models': 'models'}
2982     def __init__(self, models=None, **unknown_fields):
2983         '''
2984         models : typing.Sequence[~DestroyModelParams]
2985         '''
2986         self.models = [DestroyModelParams.from_json(o) for o in models or []]
2987
2988
2989
2990 class DestroyRelation(Type):
2991     _toSchema = {'endpoints': 'endpoints'}
2992     _toPy = {'endpoints': 'endpoints'}
2993     def __init__(self, endpoints=None, **unknown_fields):
2994         '''
2995         endpoints : typing.Sequence[str]
2996         '''
2997         self.endpoints = endpoints
2998
2999
3000
3001 class DestroyUnitInfo(Type):
3002     _toSchema = {'destroyed_storage': 'destroyed-storage', 'detached_storage': 'detached-storage'}
3003     _toPy = {'destroyed-storage': 'destroyed_storage', 'detached-storage': 'detached_storage'}
3004     def __init__(self, destroyed_storage=None, detached_storage=None, **unknown_fields):
3005         '''
3006         destroyed_storage : typing.Sequence[~Entity]
3007         detached_storage : typing.Sequence[~Entity]
3008         '''
3009         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
3010         self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
3011
3012
3013
3014 class DestroyUnitParams(Type):
3015     _toSchema = {'destroy_storage': 'destroy-storage', 'unit_tag': 'unit-tag'}
3016     _toPy = {'destroy-storage': 'destroy_storage', 'unit-tag': 'unit_tag'}
3017     def __init__(self, destroy_storage=None, unit_tag=None, **unknown_fields):
3018         '''
3019         destroy_storage : bool
3020         unit_tag : str
3021         '''
3022         self.destroy_storage = destroy_storage
3023         self.unit_tag = unit_tag
3024
3025
3026
3027 class DestroyUnitResult(Type):
3028     _toSchema = {'error': 'error', 'info': 'info'}
3029     _toPy = {'error': 'error', 'info': 'info'}
3030     def __init__(self, error=None, info=None, **unknown_fields):
3031         '''
3032         error : Error
3033         info : DestroyUnitInfo
3034         '''
3035         self.error = Error.from_json(error) if error else None
3036         self.info = DestroyUnitInfo.from_json(info) if info else None
3037
3038
3039
3040 class DestroyUnitResults(Type):
3041     _toSchema = {'results': 'results'}
3042     _toPy = {'results': 'results'}
3043     def __init__(self, results=None, **unknown_fields):
3044         '''
3045         results : typing.Sequence[~DestroyUnitResult]
3046         '''
3047         self.results = [DestroyUnitResult.from_json(o) for o in results or []]
3048
3049
3050
3051 class DestroyUnitsParams(Type):
3052     _toSchema = {'units': 'units'}
3053     _toPy = {'units': 'units'}
3054     def __init__(self, units=None, **unknown_fields):
3055         '''
3056         units : typing.Sequence[~DestroyUnitParams]
3057         '''
3058         self.units = [DestroyUnitParams.from_json(o) for o in units or []]
3059
3060
3061
3062 class DetailedStatus(Type):
3063     _toSchema = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
3064     _toPy = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
3065     def __init__(self, data=None, err=None, info=None, kind=None, life=None, since=None, status=None, version=None, **unknown_fields):
3066         '''
3067         data : typing.Mapping[str, typing.Any]
3068         err : typing.Mapping[str, typing.Any]
3069         info : str
3070         kind : str
3071         life : str
3072         since : str
3073         status : str
3074         version : str
3075         '''
3076         self.data = data
3077         self.err = err
3078         self.info = info
3079         self.kind = kind
3080         self.life = life
3081         self.since = since
3082         self.status = status
3083         self.version = version
3084
3085
3086
3087 class DeviceBridgeInfo(Type):
3088     _toSchema = {'bridge_name': 'bridge-name', 'host_device_name': 'host-device-name'}
3089     _toPy = {'bridge-name': 'bridge_name', 'host-device-name': 'host_device_name'}
3090     def __init__(self, bridge_name=None, host_device_name=None, **unknown_fields):
3091         '''
3092         bridge_name : str
3093         host_device_name : str
3094         '''
3095         self.bridge_name = bridge_name
3096         self.host_device_name = host_device_name
3097
3098
3099
3100 class DiscoverSpacesResults(Type):
3101     _toSchema = {'results': 'results'}
3102     _toPy = {'results': 'results'}
3103     def __init__(self, results=None, **unknown_fields):
3104         '''
3105         results : typing.Sequence[~ProviderSpace]
3106         '''
3107         self.results = [ProviderSpace.from_json(o) for o in results or []]
3108
3109
3110
3111 class DistributionGroupResult(Type):
3112     _toSchema = {'error': 'error', 'result': 'result'}
3113     _toPy = {'error': 'error', 'result': 'result'}
3114     def __init__(self, error=None, result=None, **unknown_fields):
3115         '''
3116         error : Error
3117         result : typing.Sequence[str]
3118         '''
3119         self.error = Error.from_json(error) if error else None
3120         self.result = result
3121
3122
3123
3124 class DistributionGroupResults(Type):
3125     _toSchema = {'results': 'results'}
3126     _toPy = {'results': 'results'}
3127     def __init__(self, results=None, **unknown_fields):
3128         '''
3129         results : typing.Sequence[~DistributionGroupResult]
3130         '''
3131         self.results = [DistributionGroupResult.from_json(o) for o in results or []]
3132
3133
3134
3135 class DumpModelRequest(Type):
3136     _toSchema = {'entities': 'entities', 'simplified': 'simplified'}
3137     _toPy = {'entities': 'entities', 'simplified': 'simplified'}
3138     def __init__(self, entities=None, simplified=None, **unknown_fields):
3139         '''
3140         entities : typing.Sequence[~Entity]
3141         simplified : bool
3142         '''
3143         self.entities = [Entity.from_json(o) for o in entities or []]
3144         self.simplified = simplified
3145
3146
3147
3148 class Endpoint(Type):
3149     _toSchema = {'application_name': 'application-name', 'relation': 'relation'}
3150     _toPy = {'application-name': 'application_name', 'relation': 'relation'}
3151     def __init__(self, application_name=None, relation=None, **unknown_fields):
3152         '''
3153         application_name : str
3154         relation : CharmRelation
3155         '''
3156         self.application_name = application_name
3157         self.relation = CharmRelation.from_json(relation) if relation else None
3158
3159
3160
3161 class EndpointFilterAttributes(Type):
3162     _toSchema = {'interface': 'interface', 'name': 'name', 'role': 'role'}
3163     _toPy = {'interface': 'interface', 'name': 'name', 'role': 'role'}
3164     def __init__(self, interface=None, name=None, role=None, **unknown_fields):
3165         '''
3166         interface : str
3167         name : str
3168         role : str
3169         '''
3170         self.interface = interface
3171         self.name = name
3172         self.role = role
3173
3174
3175
3176 class EndpointStatus(Type):
3177     _toSchema = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
3178     _toPy = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
3179     def __init__(self, application=None, name=None, role=None, subordinate=None, **unknown_fields):
3180         '''
3181         application : str
3182         name : str
3183         role : str
3184         subordinate : bool
3185         '''
3186         self.application = application
3187         self.name = name
3188         self.role = role
3189         self.subordinate = subordinate
3190
3191
3192
3193 class Entities(Type):
3194     _toSchema = {'entities': 'entities'}
3195     _toPy = {'entities': 'entities'}
3196     def __init__(self, entities=None, **unknown_fields):
3197         '''
3198         entities : typing.Sequence[~Entity]
3199         '''
3200         self.entities = [Entity.from_json(o) for o in entities or []]
3201
3202
3203
3204 class EntitiesCharmURL(Type):
3205     _toSchema = {'entities': 'entities'}
3206     _toPy = {'entities': 'entities'}
3207     def __init__(self, entities=None, **unknown_fields):
3208         '''
3209         entities : typing.Sequence[~EntityCharmURL]
3210         '''
3211         self.entities = [EntityCharmURL.from_json(o) for o in entities or []]
3212
3213
3214
3215 class EntitiesPortRanges(Type):
3216     _toSchema = {'entities': 'entities'}
3217     _toPy = {'entities': 'entities'}
3218     def __init__(self, entities=None, **unknown_fields):
3219         '''
3220         entities : typing.Sequence[~EntityPortRange]
3221         '''
3222         self.entities = [EntityPortRange.from_json(o) for o in entities or []]
3223
3224
3225
3226 class EntitiesResult(Type):
3227     _toSchema = {'entities': 'entities', 'error': 'error'}
3228     _toPy = {'entities': 'entities', 'error': 'error'}
3229     def __init__(self, entities=None, error=None, **unknown_fields):
3230         '''
3231         entities : typing.Sequence[~Entity]
3232         error : Error
3233         '''
3234         self.entities = [Entity.from_json(o) for o in entities or []]
3235         self.error = Error.from_json(error) if error else None
3236
3237
3238
3239 class EntitiesResults(Type):
3240     _toSchema = {'results': 'results'}
3241     _toPy = {'results': 'results'}
3242     def __init__(self, results=None, **unknown_fields):
3243         '''
3244         results : typing.Sequence[~EntitiesResult]
3245         '''
3246         self.results = [EntitiesResult.from_json(o) for o in results or []]
3247
3248
3249
3250 class EntitiesVersion(Type):
3251     _toSchema = {'agent_tools': 'agent-tools'}
3252     _toPy = {'agent-tools': 'agent_tools'}
3253     def __init__(self, agent_tools=None, **unknown_fields):
3254         '''
3255         agent_tools : typing.Sequence[~EntityVersion]
3256         '''
3257         self.agent_tools = [EntityVersion.from_json(o) for o in agent_tools or []]
3258
3259
3260
3261 class EntitiesWatchResult(Type):
3262     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
3263     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
3264     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
3265         '''
3266         changes : typing.Sequence[str]
3267         error : Error
3268         watcher_id : str
3269         '''
3270         self.changes = changes
3271         self.error = Error.from_json(error) if error else None
3272         self.watcher_id = watcher_id
3273
3274
3275
3276 class Entity(Type):
3277     _toSchema = {'tag': 'tag'}
3278     _toPy = {'tag': 'tag'}
3279     def __init__(self, tag=None, **unknown_fields):
3280         '''
3281         tag : str
3282         '''
3283         self.tag = tag
3284
3285
3286
3287 class EntityAnnotations(Type):
3288     _toSchema = {'annotations': 'annotations', 'entity': 'entity'}
3289     _toPy = {'annotations': 'annotations', 'entity': 'entity'}
3290     def __init__(self, annotations=None, entity=None, **unknown_fields):
3291         '''
3292         annotations : typing.Mapping[str, str]
3293         entity : str
3294         '''
3295         self.annotations = annotations
3296         self.entity = entity
3297
3298
3299
3300 class EntityCharmURL(Type):
3301     _toSchema = {'charm_url': 'charm-url', 'tag': 'tag'}
3302     _toPy = {'charm-url': 'charm_url', 'tag': 'tag'}
3303     def __init__(self, charm_url=None, tag=None, **unknown_fields):
3304         '''
3305         charm_url : str
3306         tag : str
3307         '''
3308         self.charm_url = charm_url
3309         self.tag = tag
3310
3311
3312
3313 class EntityMacaroonArg(Type):
3314     _toSchema = {'macaroon': 'macaroon', 'tag': 'tag'}
3315     _toPy = {'macaroon': 'macaroon', 'tag': 'tag'}
3316     def __init__(self, macaroon=None, tag=None, **unknown_fields):
3317         '''
3318         macaroon : Macaroon
3319         tag : str
3320         '''
3321         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
3322         self.tag = tag
3323
3324
3325
3326 class EntityMacaroonArgs(Type):
3327     _toSchema = {'args': 'Args'}
3328     _toPy = {'Args': 'args'}
3329     def __init__(self, args=None, **unknown_fields):
3330         '''
3331         args : typing.Sequence[~EntityMacaroonArg]
3332         '''
3333         self.args = [EntityMacaroonArg.from_json(o) for o in args or []]
3334
3335
3336
3337 class EntityMetrics(Type):
3338     _toSchema = {'error': 'error', 'metrics': 'metrics'}
3339     _toPy = {'error': 'error', 'metrics': 'metrics'}
3340     def __init__(self, error=None, metrics=None, **unknown_fields):
3341         '''
3342         error : Error
3343         metrics : typing.Sequence[~MetricResult]
3344         '''
3345         self.error = Error.from_json(error) if error else None
3346         self.metrics = [MetricResult.from_json(o) for o in metrics or []]
3347
3348
3349
3350 class EntityPassword(Type):
3351     _toSchema = {'password': 'password', 'tag': 'tag'}
3352     _toPy = {'password': 'password', 'tag': 'tag'}
3353     def __init__(self, password=None, tag=None, **unknown_fields):
3354         '''
3355         password : str
3356         tag : str
3357         '''
3358         self.password = password
3359         self.tag = tag
3360
3361
3362
3363 class EntityPasswords(Type):
3364     _toSchema = {'changes': 'changes'}
3365     _toPy = {'changes': 'changes'}
3366     def __init__(self, changes=None, **unknown_fields):
3367         '''
3368         changes : typing.Sequence[~EntityPassword]
3369         '''
3370         self.changes = [EntityPassword.from_json(o) for o in changes or []]
3371
3372
3373
3374 class EntityPortRange(Type):
3375     _toSchema = {'from_port': 'from-port', 'protocol': 'protocol', 'tag': 'tag', 'to_port': 'to-port'}
3376     _toPy = {'from-port': 'from_port', 'protocol': 'protocol', 'tag': 'tag', 'to-port': 'to_port'}
3377     def __init__(self, from_port=None, protocol=None, tag=None, to_port=None, **unknown_fields):
3378         '''
3379         from_port : int
3380         protocol : str
3381         tag : str
3382         to_port : int
3383         '''
3384         self.from_port = from_port
3385         self.protocol = protocol
3386         self.tag = tag
3387         self.to_port = to_port
3388
3389
3390
3391 class EntityStatus(Type):
3392     _toSchema = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
3393     _toPy = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
3394     def __init__(self, data=None, info=None, since=None, status=None, **unknown_fields):
3395         '''
3396         data : typing.Mapping[str, typing.Any]
3397         info : str
3398         since : str
3399         status : str
3400         '''
3401         self.data = data
3402         self.info = info
3403         self.since = since
3404         self.status = status
3405
3406
3407
3408 class EntityStatusArgs(Type):
3409     _toSchema = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
3410     _toPy = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
3411     def __init__(self, data=None, info=None, status=None, tag=None, **unknown_fields):
3412         '''
3413         data : typing.Mapping[str, typing.Any]
3414         info : str
3415         status : str
3416         tag : str
3417         '''
3418         self.data = data
3419         self.info = info
3420         self.status = status
3421         self.tag = tag
3422
3423
3424
3425 class EntityString(Type):
3426     _toSchema = {'tag': 'tag', 'value': 'value'}
3427     _toPy = {'tag': 'tag', 'value': 'value'}
3428     def __init__(self, tag=None, value=None, **unknown_fields):
3429         '''
3430         tag : str
3431         value : str
3432         '''
3433         self.tag = tag
3434         self.value = value
3435
3436
3437
3438 class EntityVersion(Type):
3439     _toSchema = {'tag': 'tag', 'tools': 'tools'}
3440     _toPy = {'tag': 'tag', 'tools': 'tools'}
3441     def __init__(self, tag=None, tools=None, **unknown_fields):
3442         '''
3443         tag : str
3444         tools : Version
3445         '''
3446         self.tag = tag
3447         self.tools = Version.from_json(tools) if tools else None
3448
3449
3450
3451 class EntityWorkloadVersion(Type):
3452     _toSchema = {'tag': 'tag', 'workload_version': 'workload-version'}
3453     _toPy = {'tag': 'tag', 'workload-version': 'workload_version'}
3454     def __init__(self, tag=None, workload_version=None, **unknown_fields):
3455         '''
3456         tag : str
3457         workload_version : str
3458         '''
3459         self.tag = tag
3460         self.workload_version = workload_version
3461
3462
3463
3464 class EntityWorkloadVersions(Type):
3465     _toSchema = {'entities': 'entities'}
3466     _toPy = {'entities': 'entities'}
3467     def __init__(self, entities=None, **unknown_fields):
3468         '''
3469         entities : typing.Sequence[~EntityWorkloadVersion]
3470         '''
3471         self.entities = [EntityWorkloadVersion.from_json(o) for o in entities or []]
3472
3473
3474
3475 class EnvListArgs(Type):
3476     _toSchema = {'patterns': 'patterns'}
3477     _toPy = {'patterns': 'patterns'}
3478     def __init__(self, patterns=None, **unknown_fields):
3479         '''
3480         patterns : typing.Sequence[str]
3481         '''
3482         self.patterns = patterns
3483
3484
3485
3486 class EnvListResults(Type):
3487     _toSchema = {'results': 'results'}
3488     _toPy = {'results': 'results'}
3489     def __init__(self, results=None, **unknown_fields):
3490         '''
3491         results : typing.Sequence[~Payload]
3492         '''
3493         self.results = [Payload.from_json(o) for o in results or []]
3494
3495
3496
3497 class Error(Type):
3498     _toSchema = {'code': 'code', 'info': 'info', 'message': 'message'}
3499     _toPy = {'code': 'code', 'info': 'info', 'message': 'message'}
3500     def __init__(self, code=None, info=None, message=None, **unknown_fields):
3501         '''
3502         code : str
3503         info : ErrorInfo
3504         message : str
3505         '''
3506         self.code = code
3507         self.info = ErrorInfo.from_json(info) if info else None
3508         self.message = message
3509
3510
3511
3512 class ErrorInfo(Type):
3513     _toSchema = {'macaroon': 'macaroon', 'macaroon_path': 'macaroon-path'}
3514     _toPy = {'macaroon': 'macaroon', 'macaroon-path': 'macaroon_path'}
3515     def __init__(self, macaroon=None, macaroon_path=None, **unknown_fields):
3516         '''
3517         macaroon : Macaroon
3518         macaroon_path : str
3519         '''
3520         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
3521         self.macaroon_path = macaroon_path
3522
3523
3524
3525 class ErrorResult(Type):
3526     _toSchema = {'error': 'error'}
3527     _toPy = {'error': 'error'}
3528     def __init__(self, error=None, **unknown_fields):
3529         '''
3530         error : Error
3531         '''
3532         self.error = Error.from_json(error) if error else None
3533
3534
3535
3536 class ErrorResults(Type):
3537     _toSchema = {'results': 'results'}
3538     _toPy = {'results': 'results'}
3539     def __init__(self, results=None, **unknown_fields):
3540         '''
3541         results : typing.Sequence[~ErrorResult]
3542         '''
3543         self.results = [ErrorResult.from_json(o) for o in results or []]
3544
3545
3546
3547 class ExternalControllerInfo(Type):
3548     _toSchema = {'addrs': 'addrs', 'ca_cert': 'ca-cert', 'controller_alias': 'controller-alias', 'controller_tag': 'controller-tag'}
3549     _toPy = {'addrs': 'addrs', 'ca-cert': 'ca_cert', 'controller-alias': 'controller_alias', 'controller-tag': 'controller_tag'}
3550     def __init__(self, addrs=None, ca_cert=None, controller_alias=None, controller_tag=None, **unknown_fields):
3551         '''
3552         addrs : typing.Sequence[str]
3553         ca_cert : str
3554         controller_alias : str
3555         controller_tag : str
3556         '''
3557         self.addrs = addrs
3558         self.ca_cert = ca_cert
3559         self.controller_alias = controller_alias
3560         self.controller_tag = controller_tag
3561
3562
3563
3564 class ExternalControllerInfoResult(Type):
3565     _toSchema = {'error': 'error', 'result': 'result'}
3566     _toPy = {'error': 'error', 'result': 'result'}
3567     def __init__(self, error=None, result=None, **unknown_fields):
3568         '''
3569         error : Error
3570         result : ExternalControllerInfo
3571         '''
3572         self.error = Error.from_json(error) if error else None
3573         self.result = ExternalControllerInfo.from_json(result) if result else None
3574
3575
3576
3577 class ExternalControllerInfoResults(Type):
3578     _toSchema = {'results': 'results'}
3579     _toPy = {'results': 'results'}
3580     def __init__(self, results=None, **unknown_fields):
3581         '''
3582         results : typing.Sequence[~ExternalControllerInfoResult]
3583         '''
3584         self.results = [ExternalControllerInfoResult.from_json(o) for o in results or []]
3585
3586
3587
3588 class FanConfigEntry(Type):
3589     _toSchema = {'overlay': 'overlay', 'underlay': 'underlay'}
3590     _toPy = {'overlay': 'overlay', 'underlay': 'underlay'}
3591     def __init__(self, overlay=None, underlay=None, **unknown_fields):
3592         '''
3593         overlay : str
3594         underlay : str
3595         '''
3596         self.overlay = overlay
3597         self.underlay = underlay
3598
3599
3600
3601 class FanConfigResult(Type):
3602     _toSchema = {'fans': 'fans'}
3603     _toPy = {'fans': 'fans'}
3604     def __init__(self, fans=None, **unknown_fields):
3605         '''
3606         fans : typing.Sequence[~FanConfigEntry]
3607         '''
3608         self.fans = [FanConfigEntry.from_json(o) for o in fans or []]
3609
3610
3611
3612 class Filesystem(Type):
3613     _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'volume_tag': 'volume-tag'}
3614     _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'volume-tag': 'volume_tag'}
3615     def __init__(self, filesystem_tag=None, info=None, volume_tag=None, **unknown_fields):
3616         '''
3617         filesystem_tag : str
3618         info : FilesystemInfo
3619         volume_tag : str
3620         '''
3621         self.filesystem_tag = filesystem_tag
3622         self.info = FilesystemInfo.from_json(info) if info else None
3623         self.volume_tag = volume_tag
3624
3625
3626
3627 class FilesystemAttachment(Type):
3628     _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'machine_tag': 'machine-tag'}
3629     _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'machine-tag': 'machine_tag'}
3630     def __init__(self, filesystem_tag=None, info=None, machine_tag=None, **unknown_fields):
3631         '''
3632         filesystem_tag : str
3633         info : FilesystemAttachmentInfo
3634         machine_tag : str
3635         '''
3636         self.filesystem_tag = filesystem_tag
3637         self.info = FilesystemAttachmentInfo.from_json(info) if info else None
3638         self.machine_tag = machine_tag
3639
3640
3641
3642 class FilesystemAttachmentDetails(Type):
3643     _toSchema = {'filesystemattachmentinfo': 'FilesystemAttachmentInfo', 'life': 'life'}
3644     _toPy = {'FilesystemAttachmentInfo': 'filesystemattachmentinfo', 'life': 'life'}
3645     def __init__(self, filesystemattachmentinfo=None, life=None, **unknown_fields):
3646         '''
3647         filesystemattachmentinfo : FilesystemAttachmentInfo
3648         life : str
3649         '''
3650         self.filesystemattachmentinfo = FilesystemAttachmentInfo.from_json(filesystemattachmentinfo) if filesystemattachmentinfo else None
3651         self.life = life
3652
3653
3654
3655 class FilesystemAttachmentInfo(Type):
3656     _toSchema = {'mount_point': 'mount-point', 'read_only': 'read-only'}
3657     _toPy = {'mount-point': 'mount_point', 'read-only': 'read_only'}
3658     def __init__(self, mount_point=None, read_only=None, **unknown_fields):
3659         '''
3660         mount_point : str
3661         read_only : bool
3662         '''
3663         self.mount_point = mount_point
3664         self.read_only = read_only
3665
3666
3667
3668 class FilesystemAttachmentParams(Type):
3669     _toSchema = {'filesystem_id': 'filesystem-id', 'filesystem_tag': 'filesystem-tag', 'instance_id': 'instance-id', 'machine_tag': 'machine-tag', 'mount_point': 'mount-point', 'provider': 'provider', 'read_only': 'read-only'}
3670     _toPy = {'filesystem-id': 'filesystem_id', 'filesystem-tag': 'filesystem_tag', 'instance-id': 'instance_id', 'machine-tag': 'machine_tag', 'mount-point': 'mount_point', 'provider': 'provider', 'read-only': 'read_only'}
3671     def __init__(self, filesystem_id=None, filesystem_tag=None, instance_id=None, machine_tag=None, mount_point=None, provider=None, read_only=None, **unknown_fields):
3672         '''
3673         filesystem_id : str
3674         filesystem_tag : str
3675         instance_id : str
3676         machine_tag : str
3677         mount_point : str
3678         provider : str
3679         read_only : bool
3680         '''
3681         self.filesystem_id = filesystem_id
3682         self.filesystem_tag = filesystem_tag
3683         self.instance_id = instance_id
3684         self.machine_tag = machine_tag
3685         self.mount_point = mount_point
3686         self.provider = provider
3687         self.read_only = read_only
3688
3689
3690
3691 class FilesystemAttachmentParamsResult(Type):
3692     _toSchema = {'error': 'error', 'result': 'result'}
3693     _toPy = {'error': 'error', 'result': 'result'}
3694     def __init__(self, error=None, result=None, **unknown_fields):
3695         '''
3696         error : Error
3697         result : FilesystemAttachmentParams
3698         '''
3699         self.error = Error.from_json(error) if error else None
3700         self.result = FilesystemAttachmentParams.from_json(result) if result else None
3701
3702
3703
3704 class FilesystemAttachmentParamsResults(Type):
3705     _toSchema = {'results': 'results'}
3706     _toPy = {'results': 'results'}
3707     def __init__(self, results=None, **unknown_fields):
3708         '''
3709         results : typing.Sequence[~FilesystemAttachmentParamsResult]
3710         '''
3711         self.results = [FilesystemAttachmentParamsResult.from_json(o) for o in results or []]
3712
3713
3714
3715 class FilesystemAttachmentResult(Type):
3716     _toSchema = {'error': 'error', 'result': 'result'}
3717     _toPy = {'error': 'error', 'result': 'result'}
3718     def __init__(self, error=None, result=None, **unknown_fields):
3719         '''
3720         error : Error
3721         result : FilesystemAttachment
3722         '''
3723         self.error = Error.from_json(error) if error else None
3724         self.result = FilesystemAttachment.from_json(result) if result else None
3725
3726
3727
3728 class FilesystemAttachmentResults(Type):
3729     _toSchema = {'results': 'results'}
3730     _toPy = {'results': 'results'}
3731     def __init__(self, results=None, **unknown_fields):
3732         '''
3733         results : typing.Sequence[~FilesystemAttachmentResult]
3734         '''
3735         self.results = [FilesystemAttachmentResult.from_json(o) for o in results or []]
3736
3737
3738
3739 class FilesystemAttachments(Type):
3740     _toSchema = {'filesystem_attachments': 'filesystem-attachments'}
3741     _toPy = {'filesystem-attachments': 'filesystem_attachments'}
3742     def __init__(self, filesystem_attachments=None, **unknown_fields):
3743         '''
3744         filesystem_attachments : typing.Sequence[~FilesystemAttachment]
3745         '''
3746         self.filesystem_attachments = [FilesystemAttachment.from_json(o) for o in filesystem_attachments or []]
3747
3748
3749
3750 class FilesystemDetails(Type):
3751     _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'volume_tag': 'volume-tag'}
3752     _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'machine-attachments': 'machine_attachments', 'status': 'status', 'storage': 'storage', 'volume-tag': 'volume_tag'}
3753     def __init__(self, filesystem_tag=None, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None, **unknown_fields):
3754         '''
3755         filesystem_tag : str
3756         info : FilesystemInfo
3757         machine_attachments : typing.Mapping[str, ~FilesystemAttachmentInfo]
3758         status : EntityStatus
3759         storage : StorageDetails
3760         volume_tag : str
3761         '''
3762         self.filesystem_tag = filesystem_tag
3763         self.info = FilesystemInfo.from_json(info) if info else None
3764         self.machine_attachments = machine_attachments
3765         self.status = EntityStatus.from_json(status) if status else None
3766         self.storage = StorageDetails.from_json(storage) if storage else None
3767         self.volume_tag = volume_tag
3768
3769
3770
3771 class FilesystemDetailsListResult(Type):
3772     _toSchema = {'error': 'error', 'result': 'result'}
3773     _toPy = {'error': 'error', 'result': 'result'}
3774     def __init__(self, error=None, result=None, **unknown_fields):
3775         '''
3776         error : Error
3777         result : typing.Sequence[~FilesystemDetails]
3778         '''
3779         self.error = Error.from_json(error) if error else None
3780         self.result = [FilesystemDetails.from_json(o) for o in result or []]
3781
3782
3783
3784 class FilesystemDetailsListResults(Type):
3785     _toSchema = {'results': 'results'}
3786     _toPy = {'results': 'results'}
3787     def __init__(self, results=None, **unknown_fields):
3788         '''
3789         results : typing.Sequence[~FilesystemDetailsListResult]
3790         '''
3791         self.results = [FilesystemDetailsListResult.from_json(o) for o in results or []]
3792
3793
3794
3795 class FilesystemFilter(Type):
3796     _toSchema = {'machines': 'machines'}
3797     _toPy = {'machines': 'machines'}
3798     def __init__(self, machines=None, **unknown_fields):
3799         '''
3800         machines : typing.Sequence[str]
3801         '''
3802         self.machines = machines
3803
3804
3805
3806 class FilesystemFilters(Type):
3807     _toSchema = {'filters': 'filters'}
3808     _toPy = {'filters': 'filters'}
3809     def __init__(self, filters=None, **unknown_fields):
3810         '''
3811         filters : typing.Sequence[~FilesystemFilter]
3812         '''
3813         self.filters = [FilesystemFilter.from_json(o) for o in filters or []]
3814
3815
3816
3817 class FilesystemInfo(Type):
3818     _toSchema = {'filesystem_id': 'filesystem-id', 'size': 'size'}
3819     _toPy = {'filesystem-id': 'filesystem_id', 'size': 'size'}
3820     def __init__(self, filesystem_id=None, size=None, **unknown_fields):
3821         '''
3822         filesystem_id : str
3823         size : int
3824         '''
3825         self.filesystem_id = filesystem_id
3826         self.size = size
3827
3828
3829
3830 class FilesystemParams(Type):
3831     _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem_tag': 'filesystem-tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume_tag': 'volume-tag'}
3832     _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem-tag': 'filesystem_tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume-tag': 'volume_tag'}
3833     def __init__(self, attachment=None, attributes=None, filesystem_tag=None, provider=None, size=None, tags=None, volume_tag=None, **unknown_fields):
3834         '''
3835         attachment : FilesystemAttachmentParams
3836         attributes : typing.Mapping[str, typing.Any]
3837         filesystem_tag : str
3838         provider : str
3839         size : int
3840         tags : typing.Mapping[str, str]
3841         volume_tag : str
3842         '''
3843         self.attachment = FilesystemAttachmentParams.from_json(attachment) if attachment else None
3844         self.attributes = attributes
3845         self.filesystem_tag = filesystem_tag
3846         self.provider = provider
3847         self.size = size
3848         self.tags = tags
3849         self.volume_tag = volume_tag
3850
3851
3852
3853 class FilesystemParamsResult(Type):
3854     _toSchema = {'error': 'error', 'result': 'result'}
3855     _toPy = {'error': 'error', 'result': 'result'}
3856     def __init__(self, error=None, result=None, **unknown_fields):
3857         '''
3858         error : Error
3859         result : FilesystemParams
3860         '''
3861         self.error = Error.from_json(error) if error else None
3862         self.result = FilesystemParams.from_json(result) if result else None
3863
3864
3865
3866 class FilesystemParamsResults(Type):
3867     _toSchema = {'results': 'results'}
3868     _toPy = {'results': 'results'}
3869     def __init__(self, results=None, **unknown_fields):
3870         '''
3871         results : typing.Sequence[~FilesystemParamsResult]
3872         '''
3873         self.results = [FilesystemParamsResult.from_json(o) for o in results or []]
3874
3875
3876
3877 class FilesystemResult(Type):
3878     _toSchema = {'error': 'error', 'result': 'result'}
3879     _toPy = {'error': 'error', 'result': 'result'}
3880     def __init__(self, error=None, result=None, **unknown_fields):
3881         '''
3882         error : Error
3883         result : Filesystem
3884         '''
3885         self.error = Error.from_json(error) if error else None
3886         self.result = Filesystem.from_json(result) if result else None
3887
3888
3889
3890 class FilesystemResults(Type):
3891     _toSchema = {'results': 'results'}
3892     _toPy = {'results': 'results'}
3893     def __init__(self, results=None, **unknown_fields):
3894         '''
3895         results : typing.Sequence[~FilesystemResult]
3896         '''
3897         self.results = [FilesystemResult.from_json(o) for o in results or []]
3898
3899
3900
3901 class Filesystems(Type):
3902     _toSchema = {'filesystems': 'filesystems'}
3903     _toPy = {'filesystems': 'filesystems'}
3904     def __init__(self, filesystems=None, **unknown_fields):
3905         '''
3906         filesystems : typing.Sequence[~Filesystem]
3907         '''
3908         self.filesystems = [Filesystem.from_json(o) for o in filesystems or []]
3909
3910
3911
3912 class FindActionsByNames(Type):
3913     _toSchema = {'names': 'names'}
3914     _toPy = {'names': 'names'}
3915     def __init__(self, names=None, **unknown_fields):
3916         '''
3917         names : typing.Sequence[str]
3918         '''
3919         self.names = names
3920
3921
3922
3923 class FindTags(Type):
3924     _toSchema = {'prefixes': 'prefixes'}
3925     _toPy = {'prefixes': 'prefixes'}
3926     def __init__(self, prefixes=None, **unknown_fields):
3927         '''
3928         prefixes : typing.Sequence[str]
3929         '''
3930         self.prefixes = prefixes
3931
3932
3933
3934 class FindTagsResults(Type):
3935     _toSchema = {'matches': 'matches'}
3936     _toPy = {'matches': 'matches'}
3937     def __init__(self, matches=None, **unknown_fields):
3938         '''
3939         matches : typing.Sequence[~Entity]
3940         '''
3941         self.matches = [Entity.from_json(o) for o in matches or []]
3942
3943
3944
3945 class FindToolsParams(Type):
3946     _toSchema = {'arch': 'arch', 'major': 'major', 'minor': 'minor', 'number': 'number', 'series': 'series'}
3947     _toPy = {'arch': 'arch', 'major': 'major', 'minor': 'minor', 'number': 'number', 'series': 'series'}
3948     def __init__(self, arch=None, major=None, minor=None, number=None, series=None, **unknown_fields):
3949         '''
3950         arch : str
3951         major : int
3952         minor : int
3953         number : Number
3954         series : str
3955         '''
3956         self.arch = arch
3957         self.major = major
3958         self.minor = minor
3959         self.number = Number.from_json(number) if number else None
3960         self.series = series
3961
3962
3963
3964 class FindToolsResult(Type):
3965     _toSchema = {'error': 'error', 'list_': 'list'}
3966     _toPy = {'error': 'error', 'list': 'list_'}
3967     def __init__(self, error=None, list_=None, **unknown_fields):
3968         '''
3969         error : Error
3970         list_ : typing.Sequence[~Tools]
3971         '''
3972         self.error = Error.from_json(error) if error else None
3973         self.list_ = [Tools.from_json(o) for o in list_ or []]
3974
3975
3976
3977 class FirewallRule(Type):
3978     _toSchema = {'known_service': 'known-service', 'whitelist_cidrs': 'whitelist-cidrs'}
3979     _toPy = {'known-service': 'known_service', 'whitelist-cidrs': 'whitelist_cidrs'}
3980     def __init__(self, known_service=None, whitelist_cidrs=None, **unknown_fields):
3981         '''
3982         known_service : str
3983         whitelist_cidrs : typing.Sequence[str]
3984         '''
3985         self.known_service = known_service
3986         self.whitelist_cidrs = whitelist_cidrs
3987
3988
3989
3990 class FirewallRuleArgs(Type):
3991     _toSchema = {'args': 'args'}
3992     _toPy = {'args': 'args'}
3993     def __init__(self, args=None, **unknown_fields):
3994         '''
3995         args : typing.Sequence[~FirewallRule]
3996         '''
3997         self.args = [FirewallRule.from_json(o) for o in args or []]
3998
3999
4000
4001 class FullStatus(Type):
4002     _toSchema = {'applications': 'applications', 'controller_timestamp': 'controller-timestamp', 'machines': 'machines', 'model': 'model', 'offers': 'offers', 'relations': 'relations', 'remote_applications': 'remote-applications'}
4003     _toPy = {'applications': 'applications', 'controller-timestamp': 'controller_timestamp', 'machines': 'machines', 'model': 'model', 'offers': 'offers', 'relations': 'relations', 'remote-applications': 'remote_applications'}
4004     def __init__(self, applications=None, controller_timestamp=None, machines=None, model=None, offers=None, relations=None, remote_applications=None, **unknown_fields):
4005         '''
4006         applications : typing.Mapping[str, ~ApplicationStatus]
4007         controller_timestamp : str
4008         machines : typing.Mapping[str, ~MachineStatus]
4009         model : ModelStatusInfo
4010         offers : typing.Mapping[str, ~ApplicationOfferStatus]
4011         relations : typing.Sequence[~RelationStatus]
4012         remote_applications : typing.Mapping[str, ~RemoteApplicationStatus]
4013         '''
4014         self.applications = applications
4015         self.controller_timestamp = controller_timestamp
4016         self.machines = machines
4017         self.model = ModelStatusInfo.from_json(model) if model else None
4018         self.offers = offers
4019         self.relations = [RelationStatus.from_json(o) for o in relations or []]
4020         self.remote_applications = remote_applications
4021
4022
4023
4024 class GetApplicationConstraints(Type):
4025     _toSchema = {'application': 'application'}
4026     _toPy = {'application': 'application'}
4027     def __init__(self, application=None, **unknown_fields):
4028         '''
4029         application : str
4030         '''
4031         self.application = application
4032
4033
4034
4035 class GetConstraintsResults(Type):
4036     _toSchema = {'constraints': 'constraints'}
4037     _toPy = {'constraints': 'constraints'}
4038     def __init__(self, constraints=None, **unknown_fields):
4039         '''
4040         constraints : Value
4041         '''
4042         self.constraints = Value.from_json(constraints) if constraints else None
4043
4044
4045
4046 class GetLeadershipSettingsBulkResults(Type):
4047     _toSchema = {'results': 'results'}
4048     _toPy = {'results': 'results'}
4049     def __init__(self, results=None, **unknown_fields):
4050         '''
4051         results : typing.Sequence[~GetLeadershipSettingsResult]
4052         '''
4053         self.results = [GetLeadershipSettingsResult.from_json(o) for o in results or []]
4054
4055
4056
4057 class GetLeadershipSettingsResult(Type):
4058     _toSchema = {'error': 'error', 'settings': 'settings'}
4059     _toPy = {'error': 'error', 'settings': 'settings'}
4060     def __init__(self, error=None, settings=None, **unknown_fields):
4061         '''
4062         error : Error
4063         settings : typing.Mapping[str, str]
4064         '''
4065         self.error = Error.from_json(error) if error else None
4066         self.settings = settings
4067
4068
4069
4070 class GetTokenArg(Type):
4071     _toSchema = {'tag': 'tag'}
4072     _toPy = {'tag': 'tag'}
4073     def __init__(self, tag=None, **unknown_fields):
4074         '''
4075         tag : str
4076         '''
4077         self.tag = tag
4078
4079
4080
4081 class GetTokenArgs(Type):
4082     _toSchema = {'args': 'Args'}
4083     _toPy = {'Args': 'args'}
4084     def __init__(self, args=None, **unknown_fields):
4085         '''
4086         args : typing.Sequence[~GetTokenArg]
4087         '''
4088         self.args = [GetTokenArg.from_json(o) for o in args or []]
4089
4090
4091
4092 class GoalState(Type):
4093     _toSchema = {'relations': 'relations', 'units': 'units'}
4094     _toPy = {'relations': 'relations', 'units': 'units'}
4095     def __init__(self, relations=None, units=None, **unknown_fields):
4096         '''
4097         relations : typing.Mapping[str, typing.Any]
4098         units : typing.Mapping[str, ~GoalStateStatus]
4099         '''
4100         self.relations = relations
4101         self.units = units
4102
4103
4104
4105 class GoalStateResult(Type):
4106     _toSchema = {'error': 'error', 'result': 'result'}
4107     _toPy = {'error': 'error', 'result': 'result'}
4108     def __init__(self, error=None, result=None, **unknown_fields):
4109         '''
4110         error : Error
4111         result : GoalState
4112         '''
4113         self.error = Error.from_json(error) if error else None
4114         self.result = GoalState.from_json(result) if result else None
4115
4116
4117
4118 class GoalStateResults(Type):
4119     _toSchema = {'results': 'results'}
4120     _toPy = {'results': 'results'}
4121     def __init__(self, results=None, **unknown_fields):
4122         '''
4123         results : typing.Sequence[~GoalStateResult]
4124         '''
4125         self.results = [GoalStateResult.from_json(o) for o in results or []]
4126
4127
4128
4129 class GoalStateStatus(Type):
4130     _toSchema = {'since': 'since', 'status': 'status'}
4131     _toPy = {'since': 'since', 'status': 'status'}
4132     def __init__(self, since=None, status=None, **unknown_fields):
4133         '''
4134         since : str
4135         status : str
4136         '''
4137         self.since = since
4138         self.status = status
4139
4140
4141
4142 class HAMember(Type):
4143     _toSchema = {'public_address': 'public-address', 'series': 'series', 'tag': 'tag'}
4144     _toPy = {'public-address': 'public_address', 'series': 'series', 'tag': 'tag'}
4145     def __init__(self, public_address=None, series=None, tag=None, **unknown_fields):
4146         '''
4147         public_address : Address
4148         series : str
4149         tag : str
4150         '''
4151         self.public_address = Address.from_json(public_address) if public_address else None
4152         self.series = series
4153         self.tag = tag
4154
4155
4156
4157 class HardwareCharacteristics(Type):
4158     _toSchema = {'arch': 'arch', 'availability_zone': 'availability-zone', 'cpu_cores': 'cpu-cores', 'cpu_power': 'cpu-power', 'mem': 'mem', 'root_disk': 'root-disk', 'tags': 'tags'}
4159     _toPy = {'arch': 'arch', 'availability-zone': 'availability_zone', 'cpu-cores': 'cpu_cores', 'cpu-power': 'cpu_power', 'mem': 'mem', 'root-disk': 'root_disk', 'tags': 'tags'}
4160     def __init__(self, arch=None, availability_zone=None, cpu_cores=None, cpu_power=None, mem=None, root_disk=None, tags=None, **unknown_fields):
4161         '''
4162         arch : str
4163         availability_zone : str
4164         cpu_cores : int
4165         cpu_power : int
4166         mem : int
4167         root_disk : int
4168         tags : typing.Sequence[str]
4169         '''
4170         self.arch = arch
4171         self.availability_zone = availability_zone
4172         self.cpu_cores = cpu_cores
4173         self.cpu_power = cpu_power
4174         self.mem = mem
4175         self.root_disk = root_disk
4176         self.tags = tags
4177
4178
4179
4180 class History(Type):
4181     _toSchema = {'error': 'error', 'statuses': 'statuses'}
4182     _toPy = {'error': 'error', 'statuses': 'statuses'}
4183     def __init__(self, error=None, statuses=None, **unknown_fields):
4184         '''
4185         error : Error
4186         statuses : typing.Sequence[~DetailedStatus]
4187         '''
4188         self.error = Error.from_json(error) if error else None
4189         self.statuses = [DetailedStatus.from_json(o) for o in statuses or []]
4190
4191
4192
4193 class HostNetworkChange(Type):
4194     _toSchema = {'error': 'error', 'new_bridges': 'new-bridges', 'reconfigure_delay': 'reconfigure-delay'}
4195     _toPy = {'error': 'error', 'new-bridges': 'new_bridges', 'reconfigure-delay': 'reconfigure_delay'}
4196     def __init__(self, error=None, new_bridges=None, reconfigure_delay=None, **unknown_fields):
4197         '''
4198         error : Error
4199         new_bridges : typing.Sequence[~DeviceBridgeInfo]
4200         reconfigure_delay : int
4201         '''
4202         self.error = Error.from_json(error) if error else None
4203         self.new_bridges = [DeviceBridgeInfo.from_json(o) for o in new_bridges or []]
4204         self.reconfigure_delay = reconfigure_delay
4205
4206
4207
4208 class HostNetworkChangeResults(Type):
4209     _toSchema = {'results': 'results'}
4210     _toPy = {'results': 'results'}
4211     def __init__(self, results=None, **unknown_fields):
4212         '''
4213         results : typing.Sequence[~HostNetworkChange]
4214         '''
4215         self.results = [HostNetworkChange.from_json(o) for o in results or []]
4216
4217
4218
4219 class HostPort(Type):
4220     _toSchema = {'address': 'Address', 'port': 'port'}
4221     _toPy = {'Address': 'address', 'port': 'port'}
4222     def __init__(self, address=None, port=None, **unknown_fields):
4223         '''
4224         address : Address
4225         port : int
4226         '''
4227         self.address = Address.from_json(address) if address else None
4228         self.port = port
4229
4230
4231
4232 class HostedModelConfig(Type):
4233     _toSchema = {'cloud_spec': 'cloud-spec', 'config': 'config', 'error': 'error', 'name': 'name', 'owner': 'owner'}
4234     _toPy = {'cloud-spec': 'cloud_spec', 'config': 'config', 'error': 'error', 'name': 'name', 'owner': 'owner'}
4235     def __init__(self, cloud_spec=None, config=None, error=None, name=None, owner=None, **unknown_fields):
4236         '''
4237         cloud_spec : CloudSpec
4238         config : typing.Mapping[str, typing.Any]
4239         error : Error
4240         name : str
4241         owner : str
4242         '''
4243         self.cloud_spec = CloudSpec.from_json(cloud_spec) if cloud_spec else None
4244         self.config = config
4245         self.error = Error.from_json(error) if error else None
4246         self.name = name
4247         self.owner = owner
4248
4249
4250
4251 class HostedModelConfigsResults(Type):
4252     _toSchema = {'models': 'models'}
4253     _toPy = {'models': 'models'}
4254     def __init__(self, models=None, **unknown_fields):
4255         '''
4256         models : typing.Sequence[~HostedModelConfig]
4257         '''
4258         self.models = [HostedModelConfig.from_json(o) for o in models or []]
4259
4260
4261
4262 class ImageFilterParams(Type):
4263     _toSchema = {'images': 'images'}
4264     _toPy = {'images': 'images'}
4265     def __init__(self, images=None, **unknown_fields):
4266         '''
4267         images : typing.Sequence[~ImageSpec]
4268         '''
4269         self.images = [ImageSpec.from_json(o) for o in images or []]
4270
4271
4272
4273 class ImageMetadata(Type):
4274     _toSchema = {'arch': 'arch', 'created': 'created', 'kind': 'kind', 'series': 'series', 'url': 'url'}
4275     _toPy = {'arch': 'arch', 'created': 'created', 'kind': 'kind', 'series': 'series', 'url': 'url'}
4276     def __init__(self, arch=None, created=None, kind=None, series=None, url=None, **unknown_fields):
4277         '''
4278         arch : str
4279         created : str
4280         kind : str
4281         series : str
4282         url : str
4283         '''
4284         self.arch = arch
4285         self.created = created
4286         self.kind = kind
4287         self.series = series
4288         self.url = url
4289
4290
4291
4292 class ImageMetadataFilter(Type):
4293     _toSchema = {'arches': 'arches', 'region': 'region', 'root_storage_type': 'root-storage-type', 'series': 'series', 'stream': 'stream', 'virt_type': 'virt-type'}
4294     _toPy = {'arches': 'arches', 'region': 'region', 'root-storage-type': 'root_storage_type', 'series': 'series', 'stream': 'stream', 'virt-type': 'virt_type'}
4295     def __init__(self, arches=None, region=None, root_storage_type=None, series=None, stream=None, virt_type=None, **unknown_fields):
4296         '''
4297         arches : typing.Sequence[str]
4298         region : str
4299         root_storage_type : str
4300         series : typing.Sequence[str]
4301         stream : str
4302         virt_type : str
4303         '''
4304         self.arches = arches
4305         self.region = region
4306         self.root_storage_type = root_storage_type
4307         self.series = series
4308         self.stream = stream
4309         self.virt_type = virt_type
4310
4311
4312
4313 class ImageSpec(Type):
4314     _toSchema = {'arch': 'arch', 'kind': 'kind', 'series': 'series'}
4315     _toPy = {'arch': 'arch', 'kind': 'kind', 'series': 'series'}
4316     def __init__(self, arch=None, kind=None, series=None, **unknown_fields):
4317         '''
4318         arch : str
4319         kind : str
4320         series : str
4321         '''
4322         self.arch = arch
4323         self.kind = kind
4324         self.series = series
4325
4326
4327
4328 class ImportStorageDetails(Type):
4329     _toSchema = {'storage_tag': 'storage-tag'}
4330     _toPy = {'storage-tag': 'storage_tag'}
4331     def __init__(self, storage_tag=None, **unknown_fields):
4332         '''
4333         storage_tag : str
4334         '''
4335         self.storage_tag = storage_tag
4336
4337
4338
4339 class ImportStorageParams(Type):
4340     _toSchema = {'kind': 'kind', 'pool': 'pool', 'provider_id': 'provider-id', 'storage_name': 'storage-name'}
4341     _toPy = {'kind': 'kind', 'pool': 'pool', 'provider-id': 'provider_id', 'storage-name': 'storage_name'}
4342     def __init__(self, kind=None, pool=None, provider_id=None, storage_name=None, **unknown_fields):
4343         '''
4344         kind : int
4345         pool : str
4346         provider_id : str
4347         storage_name : str
4348         '''
4349         self.kind = kind
4350         self.pool = pool
4351         self.provider_id = provider_id
4352         self.storage_name = storage_name
4353
4354
4355
4356 class ImportStorageResult(Type):
4357     _toSchema = {'error': 'error', 'result': 'result'}
4358     _toPy = {'error': 'error', 'result': 'result'}
4359     def __init__(self, error=None, result=None, **unknown_fields):
4360         '''
4361         error : Error
4362         result : ImportStorageDetails
4363         '''
4364         self.error = Error.from_json(error) if error else None
4365         self.result = ImportStorageDetails.from_json(result) if result else None
4366
4367
4368
4369 class ImportStorageResults(Type):
4370     _toSchema = {'results': 'results'}
4371     _toPy = {'results': 'results'}
4372     def __init__(self, results=None, **unknown_fields):
4373         '''
4374         results : typing.Sequence[~ImportStorageResult]
4375         '''
4376         self.results = [ImportStorageResult.from_json(o) for o in results or []]
4377
4378
4379
4380 class IngressNetworksChangeEvent(Type):
4381     _toSchema = {'application_token': 'application-token', 'ingress_required': 'ingress-required', 'macaroons': 'macaroons', 'networks': 'networks', 'relation_token': 'relation-token'}
4382     _toPy = {'application-token': 'application_token', 'ingress-required': 'ingress_required', 'macaroons': 'macaroons', 'networks': 'networks', 'relation-token': 'relation_token'}
4383     def __init__(self, application_token=None, ingress_required=None, macaroons=None, networks=None, relation_token=None, **unknown_fields):
4384         '''
4385         application_token : str
4386         ingress_required : bool
4387         macaroons : typing.Sequence[~Macaroon]
4388         networks : typing.Sequence[str]
4389         relation_token : str
4390         '''
4391         self.application_token = application_token
4392         self.ingress_required = ingress_required
4393         self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
4394         self.networks = networks
4395         self.relation_token = relation_token
4396
4397
4398
4399 class IngressNetworksChanges(Type):
4400     _toSchema = {'changes': 'changes'}
4401     _toPy = {'changes': 'changes'}
4402     def __init__(self, changes=None, **unknown_fields):
4403         '''
4404         changes : typing.Sequence[~IngressNetworksChangeEvent]
4405         '''
4406         self.changes = [IngressNetworksChangeEvent.from_json(o) for o in changes or []]
4407
4408
4409
4410 class InitiateMigrationArgs(Type):
4411     _toSchema = {'specs': 'specs'}
4412     _toPy = {'specs': 'specs'}
4413     def __init__(self, specs=None, **unknown_fields):
4414         '''
4415         specs : typing.Sequence[~MigrationSpec]
4416         '''
4417         self.specs = [MigrationSpec.from_json(o) for o in specs or []]
4418
4419
4420
4421 class InitiateMigrationResult(Type):
4422     _toSchema = {'error': 'error', 'migration_id': 'migration-id', 'model_tag': 'model-tag'}
4423     _toPy = {'error': 'error', 'migration-id': 'migration_id', 'model-tag': 'model_tag'}
4424     def __init__(self, error=None, migration_id=None, model_tag=None, **unknown_fields):
4425         '''
4426         error : Error
4427         migration_id : str
4428         model_tag : str
4429         '''
4430         self.error = Error.from_json(error) if error else None
4431         self.migration_id = migration_id
4432         self.model_tag = model_tag
4433
4434
4435
4436 class InitiateMigrationResults(Type):
4437     _toSchema = {'results': 'results'}
4438     _toPy = {'results': 'results'}
4439     def __init__(self, results=None, **unknown_fields):
4440         '''
4441         results : typing.Sequence[~InitiateMigrationResult]
4442         '''
4443         self.results = [InitiateMigrationResult.from_json(o) for o in results or []]
4444
4445
4446
4447 class InstanceInfo(Type):
4448     _toSchema = {'characteristics': 'characteristics', 'instance_id': 'instance-id', 'network_config': 'network-config', 'nonce': 'nonce', 'tag': 'tag', 'volume_attachments': 'volume-attachments', 'volumes': 'volumes'}
4449     _toPy = {'characteristics': 'characteristics', 'instance-id': 'instance_id', 'network-config': 'network_config', 'nonce': 'nonce', 'tag': 'tag', 'volume-attachments': 'volume_attachments', 'volumes': 'volumes'}
4450     def __init__(self, characteristics=None, instance_id=None, network_config=None, nonce=None, tag=None, volume_attachments=None, volumes=None, **unknown_fields):
4451         '''
4452         characteristics : HardwareCharacteristics
4453         instance_id : str
4454         network_config : typing.Sequence[~NetworkConfig]
4455         nonce : str
4456         tag : str
4457         volume_attachments : typing.Mapping[str, ~VolumeAttachmentInfo]
4458         volumes : typing.Sequence[~Volume]
4459         '''
4460         self.characteristics = HardwareCharacteristics.from_json(characteristics) if characteristics else None
4461         self.instance_id = instance_id
4462         self.network_config = [NetworkConfig.from_json(o) for o in network_config or []]
4463         self.nonce = nonce
4464         self.tag = tag
4465         self.volume_attachments = volume_attachments
4466         self.volumes = [Volume.from_json(o) for o in volumes or []]
4467
4468
4469
4470 class InstanceType(Type):
4471     _toSchema = {'arches': 'arches', 'cost': 'cost', 'cpu_cores': 'cpu-cores', 'deprecated': 'deprecated', 'memory': 'memory', 'name': 'name', 'root_disk': 'root-disk', 'virt_type': 'virt-type'}
4472     _toPy = {'arches': 'arches', 'cost': 'cost', 'cpu-cores': 'cpu_cores', 'deprecated': 'deprecated', 'memory': 'memory', 'name': 'name', 'root-disk': 'root_disk', 'virt-type': 'virt_type'}
4473     def __init__(self, arches=None, cost=None, cpu_cores=None, deprecated=None, memory=None, name=None, root_disk=None, virt_type=None, **unknown_fields):
4474         '''
4475         arches : typing.Sequence[str]
4476         cost : int
4477         cpu_cores : int
4478         deprecated : bool
4479         memory : int
4480         name : str
4481         root_disk : int
4482         virt_type : str
4483         '''
4484         self.arches = arches
4485         self.cost = cost
4486         self.cpu_cores = cpu_cores
4487         self.deprecated = deprecated
4488         self.memory = memory
4489         self.name = name
4490         self.root_disk = root_disk
4491         self.virt_type = virt_type
4492
4493
4494
4495 class InstanceTypesResult(Type):
4496     _toSchema = {'cost_currency': 'cost-currency', 'cost_divisor': 'cost-divisor', 'cost_unit': 'cost-unit', 'error': 'error', 'instance_types': 'instance-types'}
4497     _toPy = {'cost-currency': 'cost_currency', 'cost-divisor': 'cost_divisor', 'cost-unit': 'cost_unit', 'error': 'error', 'instance-types': 'instance_types'}
4498     def __init__(self, cost_currency=None, cost_divisor=None, cost_unit=None, error=None, instance_types=None, **unknown_fields):
4499         '''
4500         cost_currency : str
4501         cost_divisor : int
4502         cost_unit : str
4503         error : Error
4504         instance_types : typing.Sequence[~InstanceType]
4505         '''
4506         self.cost_currency = cost_currency
4507         self.cost_divisor = cost_divisor
4508         self.cost_unit = cost_unit
4509         self.error = Error.from_json(error) if error else None
4510         self.instance_types = [InstanceType.from_json(o) for o in instance_types or []]
4511
4512
4513
4514 class InstanceTypesResults(Type):
4515     _toSchema = {'results': 'results'}
4516     _toPy = {'results': 'results'}
4517     def __init__(self, results=None, **unknown_fields):
4518         '''
4519         results : typing.Sequence[~InstanceTypesResult]
4520         '''
4521         self.results = [InstanceTypesResult.from_json(o) for o in results or []]
4522
4523
4524
4525 class InstancesInfo(Type):
4526     _toSchema = {'machines': 'machines'}
4527     _toPy = {'machines': 'machines'}
4528     def __init__(self, machines=None, **unknown_fields):
4529         '''
4530         machines : typing.Sequence[~InstanceInfo]
4531         '''
4532         self.machines = [InstanceInfo.from_json(o) for o in machines or []]
4533
4534
4535
4536 class IntResult(Type):
4537     _toSchema = {'error': 'error', 'result': 'result'}
4538     _toPy = {'error': 'error', 'result': 'result'}
4539     def __init__(self, error=None, result=None, **unknown_fields):
4540         '''
4541         error : Error
4542         result : int
4543         '''
4544         self.error = Error.from_json(error) if error else None
4545         self.result = result
4546
4547
4548
4549 class IntResults(Type):
4550     _toSchema = {'results': 'results'}
4551     _toPy = {'results': 'results'}
4552     def __init__(self, results=None, **unknown_fields):
4553         '''
4554         results : typing.Sequence[~IntResult]
4555         '''
4556         self.results = [IntResult.from_json(o) for o in results or []]
4557
4558
4559
4560 class InterfaceAddress(Type):
4561     _toSchema = {'cidr': 'cidr', 'value': 'value'}
4562     _toPy = {'cidr': 'cidr', 'value': 'value'}
4563     def __init__(self, cidr=None, value=None, **unknown_fields):
4564         '''
4565         cidr : str
4566         value : str
4567         '''
4568         self.cidr = cidr
4569         self.value = value
4570
4571
4572
4573 class InvalidateCredentialArg(Type):
4574     _toSchema = {'reason': 'reason'}
4575     _toPy = {'reason': 'reason'}
4576     def __init__(self, reason=None, **unknown_fields):
4577         '''
4578         reason : str
4579         '''
4580         self.reason = reason
4581
4582
4583
4584 class IsMasterResult(Type):
4585     _toSchema = {'master': 'master'}
4586     _toPy = {'master': 'master'}
4587     def __init__(self, master=None, **unknown_fields):
4588         '''
4589         master : bool
4590         '''
4591         self.master = master
4592
4593
4594
4595 class IsMeteredResult(Type):
4596     _toSchema = {'metered': 'metered'}
4597     _toPy = {'metered': 'metered'}
4598     def __init__(self, metered=None, **unknown_fields):
4599         '''
4600         metered : bool
4601         '''
4602         self.metered = metered
4603
4604
4605
4606 class JobsResult(Type):
4607     _toSchema = {'error': 'error', 'jobs': 'jobs'}
4608     _toPy = {'error': 'error', 'jobs': 'jobs'}
4609     def __init__(self, error=None, jobs=None, **unknown_fields):
4610         '''
4611         error : Error
4612         jobs : typing.Sequence[str]
4613         '''
4614         self.error = Error.from_json(error) if error else None
4615         self.jobs = jobs
4616
4617
4618
4619 class JobsResults(Type):
4620     _toSchema = {'results': 'results'}
4621     _toPy = {'results': 'results'}
4622     def __init__(self, results=None, **unknown_fields):
4623         '''
4624         results : typing.Sequence[~JobsResult]
4625         '''
4626         self.results = [JobsResult.from_json(o) for o in results or []]
4627
4628
4629
4630 class KnownServiceArgs(Type):
4631     _toSchema = {'known_services': 'known-services'}
4632     _toPy = {'known-services': 'known_services'}
4633     def __init__(self, known_services=None, **unknown_fields):
4634         '''
4635         known_services : typing.Sequence[str]
4636         '''
4637         self.known_services = known_services
4638
4639
4640
4641 class KubernetesDeviceParams(Type):
4642     _toSchema = {'attributes': 'Attributes', 'count': 'Count', 'type_': 'Type'}
4643     _toPy = {'Attributes': 'attributes', 'Count': 'count', 'Type': 'type_'}
4644     def __init__(self, attributes=None, count=None, type_=None, **unknown_fields):
4645         '''
4646         attributes : typing.Mapping[str, str]
4647         count : int
4648         type_ : str
4649         '''
4650         self.attributes = attributes
4651         self.count = count
4652         self.type_ = type_
4653
4654
4655
4656 class KubernetesFilesystemAttachmentParams(Type):
4657     _toSchema = {'mount_point': 'mount-point', 'provider': 'provider', 'read_only': 'read-only'}
4658     _toPy = {'mount-point': 'mount_point', 'provider': 'provider', 'read-only': 'read_only'}
4659     def __init__(self, mount_point=None, provider=None, read_only=None, **unknown_fields):
4660         '''
4661         mount_point : str
4662         provider : str
4663         read_only : bool
4664         '''
4665         self.mount_point = mount_point
4666         self.provider = provider
4667         self.read_only = read_only
4668
4669
4670
4671 class KubernetesFilesystemInfo(Type):
4672     _toSchema = {'data': 'data', 'filesystem_id': 'filesystem-id', 'info': 'info', 'mount_point': 'mount-point', 'pool': 'pool', 'read_only': 'read-only', 'size': 'size', 'status': 'status', 'storagename': 'storagename', 'volume': 'volume'}
4673     _toPy = {'data': 'data', 'filesystem-id': 'filesystem_id', 'info': 'info', 'mount-point': 'mount_point', 'pool': 'pool', 'read-only': 'read_only', 'size': 'size', 'status': 'status', 'storagename': 'storagename', 'volume': 'volume'}
4674     def __init__(self, data=None, filesystem_id=None, info=None, mount_point=None, pool=None, read_only=None, size=None, status=None, storagename=None, volume=None, **unknown_fields):
4675         '''
4676         data : typing.Mapping[str, typing.Any]
4677         filesystem_id : str
4678         info : str
4679         mount_point : str
4680         pool : str
4681         read_only : bool
4682         size : int
4683         status : str
4684         storagename : str
4685         volume : KubernetesVolumeInfo
4686         '''
4687         self.data = data
4688         self.filesystem_id = filesystem_id
4689         self.info = info
4690         self.mount_point = mount_point
4691         self.pool = pool
4692         self.read_only = read_only
4693         self.size = size
4694         self.status = status
4695         self.storagename = storagename
4696         self.volume = KubernetesVolumeInfo.from_json(volume) if volume else None
4697
4698
4699
4700 class KubernetesFilesystemParams(Type):
4701     _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
4702     _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
4703     def __init__(self, attachment=None, attributes=None, provider=None, size=None, storagename=None, tags=None, **unknown_fields):
4704         '''
4705         attachment : KubernetesFilesystemAttachmentParams
4706         attributes : typing.Mapping[str, typing.Any]
4707         provider : str
4708         size : int
4709         storagename : str
4710         tags : typing.Mapping[str, str]
4711         '''
4712         self.attachment = KubernetesFilesystemAttachmentParams.from_json(attachment) if attachment else None
4713         self.attributes = attributes
4714         self.provider = provider
4715         self.size = size
4716         self.storagename = storagename
4717         self.tags = tags
4718
4719
4720
4721 class KubernetesProvisioningInfo(Type):
4722     _toSchema = {'constraints': 'constraints', 'devices': 'devices', 'filesystems': 'filesystems', 'placement': 'placement', 'pod_spec': 'pod-spec', 'tags': 'tags', 'volumes': 'volumes'}
4723     _toPy = {'constraints': 'constraints', 'devices': 'devices', 'filesystems': 'filesystems', 'placement': 'placement', 'pod-spec': 'pod_spec', 'tags': 'tags', 'volumes': 'volumes'}
4724     def __init__(self, constraints=None, devices=None, filesystems=None, placement=None, pod_spec=None, tags=None, volumes=None, **unknown_fields):
4725         '''
4726         constraints : Value
4727         devices : typing.Sequence[~KubernetesDeviceParams]
4728         filesystems : typing.Sequence[~KubernetesFilesystemParams]
4729         placement : str
4730         pod_spec : str
4731         tags : typing.Mapping[str, str]
4732         volumes : typing.Sequence[~KubernetesVolumeParams]
4733         '''
4734         self.constraints = Value.from_json(constraints) if constraints else None
4735         self.devices = [KubernetesDeviceParams.from_json(o) for o in devices or []]
4736         self.filesystems = [KubernetesFilesystemParams.from_json(o) for o in filesystems or []]
4737         self.placement = placement
4738         self.pod_spec = pod_spec
4739         self.tags = tags
4740         self.volumes = [KubernetesVolumeParams.from_json(o) for o in volumes or []]
4741
4742
4743
4744 class KubernetesProvisioningInfoResult(Type):
4745     _toSchema = {'error': 'error', 'result': 'result'}
4746     _toPy = {'error': 'error', 'result': 'result'}
4747     def __init__(self, error=None, result=None, **unknown_fields):
4748         '''
4749         error : Error
4750         result : KubernetesProvisioningInfo
4751         '''
4752         self.error = Error.from_json(error) if error else None
4753         self.result = KubernetesProvisioningInfo.from_json(result) if result else None
4754
4755
4756
4757 class KubernetesProvisioningInfoResults(Type):
4758     _toSchema = {'results': 'results'}
4759     _toPy = {'results': 'results'}
4760     def __init__(self, results=None, **unknown_fields):
4761         '''
4762         results : typing.Sequence[~KubernetesProvisioningInfoResult]
4763         '''
4764         self.results = [KubernetesProvisioningInfoResult.from_json(o) for o in results or []]
4765
4766
4767
4768 class KubernetesVolumeAttachmentParams(Type):
4769     _toSchema = {'provider': 'provider', 'read_only': 'read-only'}
4770     _toPy = {'provider': 'provider', 'read-only': 'read_only'}
4771     def __init__(self, provider=None, read_only=None, **unknown_fields):
4772         '''
4773         provider : str
4774         read_only : bool
4775         '''
4776         self.provider = provider
4777         self.read_only = read_only
4778
4779
4780
4781 class KubernetesVolumeInfo(Type):
4782     _toSchema = {'data': 'data', 'info': 'info', 'persistent': 'persistent', 'pool': 'pool', 'size': 'size', 'status': 'status', 'volume_id': 'volume-id'}
4783     _toPy = {'data': 'data', 'info': 'info', 'persistent': 'persistent', 'pool': 'pool', 'size': 'size', 'status': 'status', 'volume-id': 'volume_id'}
4784     def __init__(self, data=None, info=None, persistent=None, pool=None, size=None, status=None, volume_id=None, **unknown_fields):
4785         '''
4786         data : typing.Mapping[str, typing.Any]
4787         info : str
4788         persistent : bool
4789         pool : str
4790         size : int
4791         status : str
4792         volume_id : str
4793         '''
4794         self.data = data
4795         self.info = info
4796         self.persistent = persistent
4797         self.pool = pool
4798         self.size = size
4799         self.status = status
4800         self.volume_id = volume_id
4801
4802
4803
4804 class KubernetesVolumeParams(Type):
4805     _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
4806     _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
4807     def __init__(self, attachment=None, attributes=None, provider=None, size=None, storagename=None, tags=None, **unknown_fields):
4808         '''
4809         attachment : KubernetesVolumeAttachmentParams
4810         attributes : typing.Mapping[str, typing.Any]
4811         provider : str
4812         size : int
4813         storagename : str
4814         tags : typing.Mapping[str, str]
4815         '''
4816         self.attachment = KubernetesVolumeAttachmentParams.from_json(attachment) if attachment else None
4817         self.attributes = attributes
4818         self.provider = provider
4819         self.size = size
4820         self.storagename = storagename
4821         self.tags = tags
4822
4823
4824
4825 class LXDProfile(Type):
4826     _toSchema = {'config': 'config', 'description': 'description', 'devices': 'devices'}
4827     _toPy = {'config': 'config', 'description': 'description', 'devices': 'devices'}
4828     def __init__(self, config=None, description=None, devices=None, **unknown_fields):
4829         '''
4830         config : typing.Mapping[str, str]
4831         description : str
4832         devices : typing.Mapping[str, typing.Any]
4833         '''
4834         self.config = config
4835         self.description = description
4836         self.devices = devices
4837
4838
4839
4840 class LXDProfileUpgradeMessages(Type):
4841     _toSchema = {'application': 'application', 'watcher_id': 'watcher-id'}
4842     _toPy = {'application': 'application', 'watcher-id': 'watcher_id'}
4843     def __init__(self, application=None, watcher_id=None, **unknown_fields):
4844         '''
4845         application : Entity
4846         watcher_id : str
4847         '''
4848         self.application = Entity.from_json(application) if application else None
4849         self.watcher_id = watcher_id
4850
4851
4852
4853 class LXDProfileUpgradeMessagesResult(Type):
4854     _toSchema = {'error': 'error', 'message': 'message', 'unit_name': 'unit-name'}
4855     _toPy = {'error': 'error', 'message': 'message', 'unit-name': 'unit_name'}
4856     def __init__(self, error=None, message=None, unit_name=None, **unknown_fields):
4857         '''
4858         error : Error
4859         message : str
4860         unit_name : str
4861         '''
4862         self.error = Error.from_json(error) if error else None
4863         self.message = message
4864         self.unit_name = unit_name
4865
4866
4867
4868 class LXDProfileUpgradeMessagesResults(Type):
4869     _toSchema = {'args': 'args'}
4870     _toPy = {'args': 'args'}
4871     def __init__(self, args=None, **unknown_fields):
4872         '''
4873         args : typing.Sequence[~LXDProfileUpgradeMessagesResult]
4874         '''
4875         self.args = [LXDProfileUpgradeMessagesResult.from_json(o) for o in args or []]
4876
4877
4878
4879 class LifeResult(Type):
4880     _toSchema = {'error': 'error', 'life': 'life'}
4881     _toPy = {'error': 'error', 'life': 'life'}
4882     def __init__(self, error=None, life=None, **unknown_fields):
4883         '''
4884         error : Error
4885         life : str
4886         '''
4887         self.error = Error.from_json(error) if error else None
4888         self.life = life
4889
4890
4891
4892 class LifeResults(Type):
4893     _toSchema = {'results': 'results'}
4894     _toPy = {'results': 'results'}
4895     def __init__(self, results=None, **unknown_fields):
4896         '''
4897         results : typing.Sequence[~LifeResult]
4898         '''
4899         self.results = [LifeResult.from_json(o) for o in results or []]
4900
4901
4902
4903 class ListCloudImageMetadataResult(Type):
4904     _toSchema = {'result': 'result'}
4905     _toPy = {'result': 'result'}
4906     def __init__(self, result=None, **unknown_fields):
4907         '''
4908         result : typing.Sequence[~CloudImageMetadata]
4909         '''
4910         self.result = [CloudImageMetadata.from_json(o) for o in result or []]
4911
4912
4913
4914 class ListCloudInfo(Type):
4915     _toSchema = {'clouddetails': 'CloudDetails', 'user_access': 'user-access'}
4916     _toPy = {'CloudDetails': 'clouddetails', 'user-access': 'user_access'}
4917     def __init__(self, clouddetails=None, user_access=None, **unknown_fields):
4918         '''
4919         clouddetails : CloudDetails
4920         user_access : str
4921         '''
4922         self.clouddetails = CloudDetails.from_json(clouddetails) if clouddetails else None
4923         self.user_access = user_access
4924
4925
4926
4927 class ListCloudInfoResult(Type):
4928     _toSchema = {'error': 'error', 'result': 'result'}
4929     _toPy = {'error': 'error', 'result': 'result'}
4930     def __init__(self, error=None, result=None, **unknown_fields):
4931         '''
4932         error : Error
4933         result : ListCloudInfo
4934         '''
4935         self.error = Error.from_json(error) if error else None
4936         self.result = ListCloudInfo.from_json(result) if result else None
4937
4938
4939
4940 class ListCloudInfoResults(Type):
4941     _toSchema = {'results': 'results'}
4942     _toPy = {'results': 'results'}
4943     def __init__(self, results=None, **unknown_fields):
4944         '''
4945         results : typing.Sequence[~ListCloudInfoResult]
4946         '''
4947         self.results = [ListCloudInfoResult.from_json(o) for o in results or []]
4948
4949
4950
4951 class ListCloudsRequest(Type):
4952     _toSchema = {'all_': 'all', 'user_tag': 'user-tag'}
4953     _toPy = {'all': 'all_', 'user-tag': 'user_tag'}
4954     def __init__(self, all_=None, user_tag=None, **unknown_fields):
4955         '''
4956         all_ : bool
4957         user_tag : str
4958         '''
4959         self.all_ = all_
4960         self.user_tag = user_tag
4961
4962
4963
4964 class ListFirewallRulesResults(Type):
4965     _toSchema = {'rules': 'Rules'}
4966     _toPy = {'Rules': 'rules'}
4967     def __init__(self, rules=None, **unknown_fields):
4968         '''
4969         rules : typing.Sequence[~FirewallRule]
4970         '''
4971         self.rules = [FirewallRule.from_json(o) for o in rules or []]
4972
4973
4974
4975 class ListImageResult(Type):
4976     _toSchema = {'result': 'result'}
4977     _toPy = {'result': 'result'}
4978     def __init__(self, result=None, **unknown_fields):
4979         '''
4980         result : typing.Sequence[~ImageMetadata]
4981         '''
4982         self.result = [ImageMetadata.from_json(o) for o in result or []]
4983
4984
4985
4986 class ListResourcesArgs(Type):
4987     _toSchema = {'entities': 'entities'}
4988     _toPy = {'entities': 'entities'}
4989     def __init__(self, entities=None, **unknown_fields):
4990         '''
4991         entities : typing.Sequence[~Entity]
4992         '''
4993         self.entities = [Entity.from_json(o) for o in entities or []]
4994
4995
4996
4997 class ListSSHKeys(Type):
4998     _toSchema = {'entities': 'entities', 'mode': 'mode'}
4999     _toPy = {'entities': 'entities', 'mode': 'mode'}
5000     def __init__(self, entities=None, mode=None, **unknown_fields):
5001         '''
5002         entities : Entities
5003         mode : bool
5004         '''
5005         self.entities = Entities.from_json(entities) if entities else None
5006         self.mode = mode
5007
5008
5009
5010 class ListSpacesResults(Type):
5011     _toSchema = {'results': 'results'}
5012     _toPy = {'results': 'results'}
5013     def __init__(self, results=None, **unknown_fields):
5014         '''
5015         results : typing.Sequence[~Space]
5016         '''
5017         self.results = [Space.from_json(o) for o in results or []]
5018
5019
5020
5021 class ListSubnetsResults(Type):
5022     _toSchema = {'results': 'results'}
5023     _toPy = {'results': 'results'}
5024     def __init__(self, results=None, **unknown_fields):
5025         '''
5026         results : typing.Sequence[~Subnet]
5027         '''
5028         self.results = [Subnet.from_json(o) for o in results or []]
5029
5030
5031
5032 class ListUnitResourcesArgs(Type):
5033     _toSchema = {'resource_names': 'resource-names'}
5034     _toPy = {'resource-names': 'resource_names'}
5035     def __init__(self, resource_names=None, **unknown_fields):
5036         '''
5037         resource_names : typing.Sequence[str]
5038         '''
5039         self.resource_names = resource_names
5040
5041
5042
5043 class LogForwardingGetLastSentParams(Type):
5044     _toSchema = {'ids': 'ids'}
5045     _toPy = {'ids': 'ids'}
5046     def __init__(self, ids=None, **unknown_fields):
5047         '''
5048         ids : typing.Sequence[~LogForwardingID]
5049         '''
5050         self.ids = [LogForwardingID.from_json(o) for o in ids or []]
5051
5052
5053
5054 class LogForwardingGetLastSentResult(Type):
5055     _toSchema = {'err': 'err', 'record_id': 'record-id', 'record_timestamp': 'record-timestamp'}
5056     _toPy = {'err': 'err', 'record-id': 'record_id', 'record-timestamp': 'record_timestamp'}
5057     def __init__(self, err=None, record_id=None, record_timestamp=None, **unknown_fields):
5058         '''
5059         err : Error
5060         record_id : int
5061         record_timestamp : int
5062         '''
5063         self.err = Error.from_json(err) if err else None
5064         self.record_id = record_id
5065         self.record_timestamp = record_timestamp
5066
5067
5068
5069 class LogForwardingGetLastSentResults(Type):
5070     _toSchema = {'results': 'results'}
5071     _toPy = {'results': 'results'}
5072     def __init__(self, results=None, **unknown_fields):
5073         '''
5074         results : typing.Sequence[~LogForwardingGetLastSentResult]
5075         '''
5076         self.results = [LogForwardingGetLastSentResult.from_json(o) for o in results or []]
5077
5078
5079
5080 class LogForwardingID(Type):
5081     _toSchema = {'model': 'model', 'sink': 'sink'}
5082     _toPy = {'model': 'model', 'sink': 'sink'}
5083     def __init__(self, model=None, sink=None, **unknown_fields):
5084         '''
5085         model : str
5086         sink : str
5087         '''
5088         self.model = model
5089         self.sink = sink
5090
5091
5092
5093 class LogForwardingSetLastSentParam(Type):
5094     _toSchema = {'logforwardingid': 'LogForwardingID', 'record_id': 'record-id', 'record_timestamp': 'record-timestamp'}
5095     _toPy = {'LogForwardingID': 'logforwardingid', 'record-id': 'record_id', 'record-timestamp': 'record_timestamp'}
5096     def __init__(self, logforwardingid=None, record_id=None, record_timestamp=None, **unknown_fields):
5097         '''
5098         logforwardingid : LogForwardingID
5099         record_id : int
5100         record_timestamp : int
5101         '''
5102         self.logforwardingid = LogForwardingID.from_json(logforwardingid) if logforwardingid else None
5103         self.record_id = record_id
5104         self.record_timestamp = record_timestamp
5105
5106
5107
5108 class LogForwardingSetLastSentParams(Type):
5109     _toSchema = {'params': 'params'}
5110     _toPy = {'params': 'params'}
5111     def __init__(self, params=None, **unknown_fields):
5112         '''
5113         params : typing.Sequence[~LogForwardingSetLastSentParam]
5114         '''
5115         self.params = [LogForwardingSetLastSentParam.from_json(o) for o in params or []]
5116
5117
5118
5119 class LookUpArg(Type):
5120     _toSchema = {'id_': 'id', 'name': 'name'}
5121     _toPy = {'id': 'id_', 'name': 'name'}
5122     def __init__(self, id_=None, name=None, **unknown_fields):
5123         '''
5124         id_ : str
5125         name : str
5126         '''
5127         self.id_ = id_
5128         self.name = name
5129
5130
5131
5132 class LookUpArgs(Type):
5133     _toSchema = {'args': 'args'}
5134     _toPy = {'args': 'args'}
5135     def __init__(self, args=None, **unknown_fields):
5136         '''
5137         args : typing.Sequence[~LookUpArg]
5138         '''
5139         self.args = [LookUpArg.from_json(o) for o in args or []]
5140
5141
5142
5143 class LookUpPayloadArg(Type):
5144     _toSchema = {'id_': 'id', 'name': 'name'}
5145     _toPy = {'id': 'id_', 'name': 'name'}
5146     def __init__(self, id_=None, name=None, **unknown_fields):
5147         '''
5148         id_ : str
5149         name : str
5150         '''
5151         self.id_ = id_
5152         self.name = name
5153
5154
5155
5156 class LookUpPayloadArgs(Type):
5157     _toSchema = {'args': 'args'}
5158     _toPy = {'args': 'args'}
5159     def __init__(self, args=None, **unknown_fields):
5160         '''
5161         args : typing.Sequence[~LookUpPayloadArg]
5162         '''
5163         self.args = [LookUpPayloadArg.from_json(o) for o in args or []]
5164
5165
5166
5167 class Macaroon(Type):
5168     _toSchema = {}
5169     _toPy = {}
5170     def __init__(self, **unknown_fields):
5171         '''
5172
5173         '''
5174         pass
5175
5176
5177
5178 class MacaroonResult(Type):
5179     _toSchema = {'error': 'error', 'result': 'result'}
5180     _toPy = {'error': 'error', 'result': 'result'}
5181     def __init__(self, error=None, result=None, **unknown_fields):
5182         '''
5183         error : Error
5184         result : Macaroon
5185         '''
5186         self.error = Error.from_json(error) if error else None
5187         self.result = Macaroon.from_json(result) if result else None
5188
5189
5190
5191 class MacaroonResults(Type):
5192     _toSchema = {'results': 'results'}
5193     _toPy = {'results': 'results'}
5194     def __init__(self, results=None, **unknown_fields):
5195         '''
5196         results : typing.Sequence[~MacaroonResult]
5197         '''
5198         self.results = [MacaroonResult.from_json(o) for o in results or []]
5199
5200
5201
5202 class MachineAddresses(Type):
5203     _toSchema = {'addresses': 'addresses', 'tag': 'tag'}
5204     _toPy = {'addresses': 'addresses', 'tag': 'tag'}
5205     def __init__(self, addresses=None, tag=None, **unknown_fields):
5206         '''
5207         addresses : typing.Sequence[~Address]
5208         tag : str
5209         '''
5210         self.addresses = [Address.from_json(o) for o in addresses or []]
5211         self.tag = tag
5212
5213
5214
5215 class MachineAddressesResult(Type):
5216     _toSchema = {'addresses': 'addresses', 'error': 'error'}
5217     _toPy = {'addresses': 'addresses', 'error': 'error'}
5218     def __init__(self, addresses=None, error=None, **unknown_fields):
5219         '''
5220         addresses : typing.Sequence[~Address]
5221         error : Error
5222         '''
5223         self.addresses = [Address.from_json(o) for o in addresses or []]
5224         self.error = Error.from_json(error) if error else None
5225
5226
5227
5228 class MachineAddressesResults(Type):
5229     _toSchema = {'results': 'results'}
5230     _toPy = {'results': 'results'}
5231     def __init__(self, results=None, **unknown_fields):
5232         '''
5233         results : typing.Sequence[~MachineAddressesResult]
5234         '''
5235         self.results = [MachineAddressesResult.from_json(o) for o in results or []]
5236
5237
5238
5239 class MachineBlockDevices(Type):
5240     _toSchema = {'block_devices': 'block-devices', 'machine': 'machine'}
5241     _toPy = {'block-devices': 'block_devices', 'machine': 'machine'}
5242     def __init__(self, block_devices=None, machine=None, **unknown_fields):
5243         '''
5244         block_devices : typing.Sequence[~BlockDevice]
5245         machine : str
5246         '''
5247         self.block_devices = [BlockDevice.from_json(o) for o in block_devices or []]
5248         self.machine = machine
5249
5250
5251
5252 class MachineContainers(Type):
5253     _toSchema = {'container_types': 'container-types', 'machine_tag': 'machine-tag'}
5254     _toPy = {'container-types': 'container_types', 'machine-tag': 'machine_tag'}
5255     def __init__(self, container_types=None, machine_tag=None, **unknown_fields):
5256         '''
5257         container_types : typing.Sequence[str]
5258         machine_tag : str
5259         '''
5260         self.container_types = container_types
5261         self.machine_tag = machine_tag
5262
5263
5264
5265 class MachineContainersParams(Type):
5266     _toSchema = {'params': 'params'}
5267     _toPy = {'params': 'params'}
5268     def __init__(self, params=None, **unknown_fields):
5269         '''
5270         params : typing.Sequence[~MachineContainers]
5271         '''
5272         self.params = [MachineContainers.from_json(o) for o in params or []]
5273
5274
5275
5276 class MachineHardware(Type):
5277     _toSchema = {'arch': 'arch', 'availability_zone': 'availability-zone', 'cores': 'cores', 'cpu_power': 'cpu-power', 'mem': 'mem', 'root_disk': 'root-disk', 'tags': 'tags'}
5278     _toPy = {'arch': 'arch', 'availability-zone': 'availability_zone', 'cores': 'cores', 'cpu-power': 'cpu_power', 'mem': 'mem', 'root-disk': 'root_disk', 'tags': 'tags'}
5279     def __init__(self, arch=None, availability_zone=None, cores=None, cpu_power=None, mem=None, root_disk=None, tags=None, **unknown_fields):
5280         '''
5281         arch : str
5282         availability_zone : str
5283         cores : int
5284         cpu_power : int
5285         mem : int
5286         root_disk : int
5287         tags : typing.Sequence[str]
5288         '''
5289         self.arch = arch
5290         self.availability_zone = availability_zone
5291         self.cores = cores
5292         self.cpu_power = cpu_power
5293         self.mem = mem
5294         self.root_disk = root_disk
5295         self.tags = tags
5296
5297
5298
5299 class MachineNetworkConfigResult(Type):
5300     _toSchema = {'error': 'error', 'info': 'info'}
5301     _toPy = {'error': 'error', 'info': 'info'}
5302     def __init__(self, error=None, info=None, **unknown_fields):
5303         '''
5304         error : Error
5305         info : typing.Sequence[~NetworkConfig]
5306         '''
5307         self.error = Error.from_json(error) if error else None
5308         self.info = [NetworkConfig.from_json(o) for o in info or []]
5309
5310
5311
5312 class MachineNetworkConfigResults(Type):
5313     _toSchema = {'results': 'results'}
5314     _toPy = {'results': 'results'}
5315     def __init__(self, results=None, **unknown_fields):
5316         '''
5317         results : typing.Sequence[~MachineNetworkConfigResult]
5318         '''
5319         self.results = [MachineNetworkConfigResult.from_json(o) for o in results or []]
5320
5321
5322
5323 class MachinePortRange(Type):
5324     _toSchema = {'port_range': 'port-range', 'relation_tag': 'relation-tag', 'unit_tag': 'unit-tag'}
5325     _toPy = {'port-range': 'port_range', 'relation-tag': 'relation_tag', 'unit-tag': 'unit_tag'}
5326     def __init__(self, port_range=None, relation_tag=None, unit_tag=None, **unknown_fields):
5327         '''
5328         port_range : PortRange
5329         relation_tag : str
5330         unit_tag : str
5331         '''
5332         self.port_range = PortRange.from_json(port_range) if port_range else None
5333         self.relation_tag = relation_tag
5334         self.unit_tag = unit_tag
5335
5336
5337
5338 class MachinePorts(Type):
5339     _toSchema = {'machine_tag': 'machine-tag', 'subnet_tag': 'subnet-tag'}
5340     _toPy = {'machine-tag': 'machine_tag', 'subnet-tag': 'subnet_tag'}
5341     def __init__(self, machine_tag=None, subnet_tag=None, **unknown_fields):
5342         '''
5343         machine_tag : str
5344         subnet_tag : str
5345         '''
5346         self.machine_tag = machine_tag
5347         self.subnet_tag = subnet_tag
5348
5349
5350
5351 class MachinePortsParams(Type):
5352     _toSchema = {'params': 'params'}
5353     _toPy = {'params': 'params'}
5354     def __init__(self, params=None, **unknown_fields):
5355         '''
5356         params : typing.Sequence[~MachinePorts]
5357         '''
5358         self.params = [MachinePorts.from_json(o) for o in params or []]
5359
5360
5361
5362 class MachinePortsResult(Type):
5363     _toSchema = {'error': 'error', 'ports': 'ports'}
5364     _toPy = {'error': 'error', 'ports': 'ports'}
5365     def __init__(self, error=None, ports=None, **unknown_fields):
5366         '''
5367         error : Error
5368         ports : typing.Sequence[~MachinePortRange]
5369         '''
5370         self.error = Error.from_json(error) if error else None
5371         self.ports = [MachinePortRange.from_json(o) for o in ports or []]
5372
5373
5374
5375 class MachinePortsResults(Type):
5376     _toSchema = {'results': 'results'}
5377     _toPy = {'results': 'results'}
5378     def __init__(self, results=None, **unknown_fields):
5379         '''
5380         results : typing.Sequence[~MachinePortsResult]
5381         '''
5382         self.results = [MachinePortsResult.from_json(o) for o in results or []]
5383
5384
5385
5386 class MachineStatus(Type):
5387     _toSchema = {'agent_status': 'agent-status', 'containers': 'containers', 'dns_name': 'dns-name', 'hardware': 'hardware', 'has_vote': 'has-vote', 'id_': 'id', 'instance_id': 'instance-id', 'instance_status': 'instance-status', 'ip_addresses': 'ip-addresses', 'jobs': 'jobs', 'series': 'series', 'wants_vote': 'wants-vote'}
5388     _toPy = {'agent-status': 'agent_status', 'containers': 'containers', 'dns-name': 'dns_name', 'hardware': 'hardware', 'has-vote': 'has_vote', 'id': 'id_', 'instance-id': 'instance_id', 'instance-status': 'instance_status', 'ip-addresses': 'ip_addresses', 'jobs': 'jobs', 'series': 'series', 'wants-vote': 'wants_vote'}
5389     def __init__(self, agent_status=None, containers=None, dns_name=None, hardware=None, has_vote=None, id_=None, instance_id=None, instance_status=None, ip_addresses=None, jobs=None, series=None, wants_vote=None, **unknown_fields):
5390         '''
5391         agent_status : DetailedStatus
5392         containers : typing.Mapping[str, ~MachineStatus]
5393         dns_name : str
5394         hardware : str
5395         has_vote : bool
5396         id_ : str
5397         instance_id : str
5398         instance_status : DetailedStatus
5399         ip_addresses : typing.Sequence[str]
5400         jobs : typing.Sequence[str]
5401         series : str
5402         wants_vote : bool
5403         '''
5404         self.agent_status = DetailedStatus.from_json(agent_status) if agent_status else None
5405         self.containers = containers
5406         self.dns_name = dns_name
5407         self.hardware = hardware
5408         self.has_vote = has_vote
5409         self.id_ = id_
5410         self.instance_id = instance_id
5411         self.instance_status = DetailedStatus.from_json(instance_status) if instance_status else None
5412         self.ip_addresses = ip_addresses
5413         self.jobs = jobs
5414         self.series = series
5415         self.wants_vote = wants_vote
5416
5417
5418
5419 class MachineStorageId(Type):
5420     _toSchema = {'attachment_tag': 'attachment-tag', 'machine_tag': 'machine-tag'}
5421     _toPy = {'attachment-tag': 'attachment_tag', 'machine-tag': 'machine_tag'}
5422     def __init__(self, attachment_tag=None, machine_tag=None, **unknown_fields):
5423         '''
5424         attachment_tag : str
5425         machine_tag : str
5426         '''
5427         self.attachment_tag = attachment_tag
5428         self.machine_tag = machine_tag
5429
5430
5431
5432 class MachineStorageIds(Type):
5433     _toSchema = {'ids': 'ids'}
5434     _toPy = {'ids': 'ids'}
5435     def __init__(self, ids=None, **unknown_fields):
5436         '''
5437         ids : typing.Sequence[~MachineStorageId]
5438         '''
5439         self.ids = [MachineStorageId.from_json(o) for o in ids or []]
5440
5441
5442
5443 class MachineStorageIdsWatchResult(Type):
5444     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
5445     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
5446     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
5447         '''
5448         changes : typing.Sequence[~MachineStorageId]
5449         error : Error
5450         watcher_id : str
5451         '''
5452         self.changes = [MachineStorageId.from_json(o) for o in changes or []]
5453         self.error = Error.from_json(error) if error else None
5454         self.watcher_id = watcher_id
5455
5456
5457
5458 class MachineStorageIdsWatchResults(Type):
5459     _toSchema = {'results': 'results'}
5460     _toPy = {'results': 'results'}
5461     def __init__(self, results=None, **unknown_fields):
5462         '''
5463         results : typing.Sequence[~MachineStorageIdsWatchResult]
5464         '''
5465         self.results = [MachineStorageIdsWatchResult.from_json(o) for o in results or []]
5466
5467
5468
5469 class MapResult(Type):
5470     _toSchema = {'error': 'error', 'result': 'result'}
5471     _toPy = {'error': 'error', 'result': 'result'}
5472     def __init__(self, error=None, result=None, **unknown_fields):
5473         '''
5474         error : Error
5475         result : typing.Mapping[str, typing.Any]
5476         '''
5477         self.error = Error.from_json(error) if error else None
5478         self.result = result
5479
5480
5481
5482 class MapResults(Type):
5483     _toSchema = {'results': 'results'}
5484     _toPy = {'results': 'results'}
5485     def __init__(self, results=None, **unknown_fields):
5486         '''
5487         results : typing.Sequence[~MapResult]
5488         '''
5489         self.results = [MapResult.from_json(o) for o in results or []]
5490
5491
5492
5493 class MasterMigrationStatus(Type):
5494     _toSchema = {'migration_id': 'migration-id', 'phase': 'phase', 'phase_changed_time': 'phase-changed-time', 'spec': 'spec'}
5495     _toPy = {'migration-id': 'migration_id', 'phase': 'phase', 'phase-changed-time': 'phase_changed_time', 'spec': 'spec'}
5496     def __init__(self, migration_id=None, phase=None, phase_changed_time=None, spec=None, **unknown_fields):
5497         '''
5498         migration_id : str
5499         phase : str
5500         phase_changed_time : str
5501         spec : MigrationSpec
5502         '''
5503         self.migration_id = migration_id
5504         self.phase = phase
5505         self.phase_changed_time = phase_changed_time
5506         self.spec = MigrationSpec.from_json(spec) if spec else None
5507
5508
5509
5510 class Member(Type):
5511     _toSchema = {'address': 'Address', 'arbiter': 'Arbiter', 'buildindexes': 'BuildIndexes', 'hidden': 'Hidden', 'id_': 'Id', 'priority': 'Priority', 'slavedelay': 'SlaveDelay', 'tags': 'Tags', 'votes': 'Votes'}
5512     _toPy = {'Address': 'address', 'Arbiter': 'arbiter', 'BuildIndexes': 'buildindexes', 'Hidden': 'hidden', 'Id': 'id_', 'Priority': 'priority', 'SlaveDelay': 'slavedelay', 'Tags': 'tags', 'Votes': 'votes'}
5513     def __init__(self, address=None, arbiter=None, buildindexes=None, hidden=None, id_=None, priority=None, slavedelay=None, tags=None, votes=None, **unknown_fields):
5514         '''
5515         address : str
5516         arbiter : bool
5517         buildindexes : bool
5518         hidden : bool
5519         id_ : int
5520         priority : float
5521         slavedelay : int
5522         tags : typing.Mapping[str, str]
5523         votes : int
5524         '''
5525         self.address = address
5526         self.arbiter = arbiter
5527         self.buildindexes = buildindexes
5528         self.hidden = hidden
5529         self.id_ = id_
5530         self.priority = priority
5531         self.slavedelay = slavedelay
5532         self.tags = tags
5533         self.votes = votes
5534
5535
5536
5537 class MergeLeadershipSettingsBulkParams(Type):
5538     _toSchema = {'params': 'params'}
5539     _toPy = {'params': 'params'}
5540     def __init__(self, params=None, **unknown_fields):
5541         '''
5542         params : typing.Sequence[~MergeLeadershipSettingsParam]
5543         '''
5544         self.params = [MergeLeadershipSettingsParam.from_json(o) for o in params or []]
5545
5546
5547
5548 class MergeLeadershipSettingsParam(Type):
5549     _toSchema = {'application_tag': 'application-tag', 'settings': 'settings'}
5550     _toPy = {'application-tag': 'application_tag', 'settings': 'settings'}
5551     def __init__(self, application_tag=None, settings=None, **unknown_fields):
5552         '''
5553         application_tag : str
5554         settings : typing.Mapping[str, str]
5555         '''
5556         self.application_tag = application_tag
5557         self.settings = settings
5558
5559
5560
5561 class MetadataImageIds(Type):
5562     _toSchema = {'image_ids': 'image-ids'}
5563     _toPy = {'image-ids': 'image_ids'}
5564     def __init__(self, image_ids=None, **unknown_fields):
5565         '''
5566         image_ids : typing.Sequence[str]
5567         '''
5568         self.image_ids = image_ids
5569
5570
5571
5572 class MetadataSaveParams(Type):
5573     _toSchema = {'metadata': 'metadata'}
5574     _toPy = {'metadata': 'metadata'}
5575     def __init__(self, metadata=None, **unknown_fields):
5576         '''
5577         metadata : typing.Sequence[~CloudImageMetadataList]
5578         '''
5579         self.metadata = [CloudImageMetadataList.from_json(o) for o in metadata or []]
5580
5581
5582
5583 class MeterStatus(Type):
5584     _toSchema = {'color': 'color', 'message': 'message'}
5585     _toPy = {'color': 'color', 'message': 'message'}
5586     def __init__(self, color=None, message=None, **unknown_fields):
5587         '''
5588         color : str
5589         message : str
5590         '''
5591         self.color = color
5592         self.message = message
5593
5594
5595
5596 class MeterStatusParam(Type):
5597     _toSchema = {'code': 'code', 'info': 'info', 'tag': 'tag'}
5598     _toPy = {'code': 'code', 'info': 'info', 'tag': 'tag'}
5599     def __init__(self, code=None, info=None, tag=None, **unknown_fields):
5600         '''
5601         code : str
5602         info : str
5603         tag : str
5604         '''
5605         self.code = code
5606         self.info = info
5607         self.tag = tag
5608
5609
5610
5611 class MeterStatusParams(Type):
5612     _toSchema = {'statues': 'statues'}
5613     _toPy = {'statues': 'statues'}
5614     def __init__(self, statues=None, **unknown_fields):
5615         '''
5616         statues : typing.Sequence[~MeterStatusParam]
5617         '''
5618         self.statues = [MeterStatusParam.from_json(o) for o in statues or []]
5619
5620
5621
5622 class MeterStatusResult(Type):
5623     _toSchema = {'code': 'code', 'error': 'error', 'info': 'info'}
5624     _toPy = {'code': 'code', 'error': 'error', 'info': 'info'}
5625     def __init__(self, code=None, error=None, info=None, **unknown_fields):
5626         '''
5627         code : str
5628         error : Error
5629         info : str
5630         '''
5631         self.code = code
5632         self.error = Error.from_json(error) if error else None
5633         self.info = info
5634
5635
5636
5637 class MeterStatusResults(Type):
5638     _toSchema = {'results': 'results'}
5639     _toPy = {'results': 'results'}
5640     def __init__(self, results=None, **unknown_fields):
5641         '''
5642         results : typing.Sequence[~MeterStatusResult]
5643         '''
5644         self.results = [MeterStatusResult.from_json(o) for o in results or []]
5645
5646
5647
5648 class Metric(Type):
5649     _toSchema = {'key': 'key', 'time': 'time', 'value': 'value'}
5650     _toPy = {'key': 'key', 'time': 'time', 'value': 'value'}
5651     def __init__(self, key=None, time=None, value=None, **unknown_fields):
5652         '''
5653         key : str
5654         time : str
5655         value : str
5656         '''
5657         self.key = key
5658         self.time = time
5659         self.value = value
5660
5661
5662
5663 class MetricBatch(Type):
5664     _toSchema = {'charm_url': 'charm-url', 'created': 'created', 'metrics': 'metrics', 'uuid': 'uuid'}
5665     _toPy = {'charm-url': 'charm_url', 'created': 'created', 'metrics': 'metrics', 'uuid': 'uuid'}
5666     def __init__(self, charm_url=None, created=None, metrics=None, uuid=None, **unknown_fields):
5667         '''
5668         charm_url : str
5669         created : str
5670         metrics : typing.Sequence[~Metric]
5671         uuid : str
5672         '''
5673         self.charm_url = charm_url
5674         self.created = created
5675         self.metrics = [Metric.from_json(o) for o in metrics or []]
5676         self.uuid = uuid
5677
5678
5679
5680 class MetricBatchParam(Type):
5681     _toSchema = {'batch': 'batch', 'tag': 'tag'}
5682     _toPy = {'batch': 'batch', 'tag': 'tag'}
5683     def __init__(self, batch=None, tag=None, **unknown_fields):
5684         '''
5685         batch : MetricBatch
5686         tag : str
5687         '''
5688         self.batch = MetricBatch.from_json(batch) if batch else None
5689         self.tag = tag
5690
5691
5692
5693 class MetricBatchParams(Type):
5694     _toSchema = {'batches': 'batches'}
5695     _toPy = {'batches': 'batches'}
5696     def __init__(self, batches=None, **unknown_fields):
5697         '''
5698         batches : typing.Sequence[~MetricBatchParam]
5699         '''
5700         self.batches = [MetricBatchParam.from_json(o) for o in batches or []]
5701
5702
5703
5704 class MetricResult(Type):
5705     _toSchema = {'key': 'key', 'time': 'time', 'unit': 'unit', 'value': 'value'}
5706     _toPy = {'key': 'key', 'time': 'time', 'unit': 'unit', 'value': 'value'}
5707     def __init__(self, key=None, time=None, unit=None, value=None, **unknown_fields):
5708         '''
5709         key : str
5710         time : str
5711         unit : str
5712         value : str
5713         '''
5714         self.key = key
5715         self.time = time
5716         self.unit = unit
5717         self.value = value
5718
5719
5720
5721 class MetricResults(Type):
5722     _toSchema = {'results': 'results'}
5723     _toPy = {'results': 'results'}
5724     def __init__(self, results=None, **unknown_fields):
5725         '''
5726         results : typing.Sequence[~EntityMetrics]
5727         '''
5728         self.results = [EntityMetrics.from_json(o) for o in results or []]
5729
5730
5731
5732 class MigrationModelInfo(Type):
5733     _toSchema = {'agent_version': 'agent-version', 'name': 'name', 'owner_tag': 'owner-tag', 'uuid': 'uuid'}
5734     _toPy = {'agent-version': 'agent_version', 'name': 'name', 'owner-tag': 'owner_tag', 'uuid': 'uuid'}
5735     def __init__(self, agent_version=None, name=None, owner_tag=None, uuid=None, **unknown_fields):
5736         '''
5737         agent_version : Number
5738         name : str
5739         owner_tag : str
5740         uuid : str
5741         '''
5742         self.agent_version = Number.from_json(agent_version) if agent_version else None
5743         self.name = name
5744         self.owner_tag = owner_tag
5745         self.uuid = uuid
5746
5747
5748
5749 class MigrationSpec(Type):
5750     _toSchema = {'external_control': 'external-control', 'model_tag': 'model-tag', 'skip_initial_prechecks': 'skip-initial-prechecks', 'target_info': 'target-info'}
5751     _toPy = {'external-control': 'external_control', 'model-tag': 'model_tag', 'skip-initial-prechecks': 'skip_initial_prechecks', 'target-info': 'target_info'}
5752     def __init__(self, external_control=None, model_tag=None, skip_initial_prechecks=None, target_info=None, **unknown_fields):
5753         '''
5754         external_control : bool
5755         model_tag : str
5756         skip_initial_prechecks : bool
5757         target_info : MigrationTargetInfo
5758         '''
5759         self.external_control = external_control
5760         self.model_tag = model_tag
5761         self.skip_initial_prechecks = skip_initial_prechecks
5762         self.target_info = MigrationTargetInfo.from_json(target_info) if target_info else None
5763
5764
5765
5766 class MigrationStatus(Type):
5767     _toSchema = {'attempt': 'attempt', 'external_control': 'external-control', 'migration_id': 'migration-id', 'phase': 'phase', 'source_api_addrs': 'source-api-addrs', 'source_ca_cert': 'source-ca-cert', 'target_api_addrs': 'target-api-addrs', 'target_ca_cert': 'target-ca-cert'}
5768     _toPy = {'attempt': 'attempt', 'external-control': 'external_control', 'migration-id': 'migration_id', 'phase': 'phase', 'source-api-addrs': 'source_api_addrs', 'source-ca-cert': 'source_ca_cert', 'target-api-addrs': 'target_api_addrs', 'target-ca-cert': 'target_ca_cert'}
5769     def __init__(self, attempt=None, external_control=None, migration_id=None, phase=None, source_api_addrs=None, source_ca_cert=None, target_api_addrs=None, target_ca_cert=None, **unknown_fields):
5770         '''
5771         attempt : int
5772         external_control : bool
5773         migration_id : str
5774         phase : str
5775         source_api_addrs : typing.Sequence[str]
5776         source_ca_cert : str
5777         target_api_addrs : typing.Sequence[str]
5778         target_ca_cert : str
5779         '''
5780         self.attempt = attempt
5781         self.external_control = external_control
5782         self.migration_id = migration_id
5783         self.phase = phase
5784         self.source_api_addrs = source_api_addrs
5785         self.source_ca_cert = source_ca_cert
5786         self.target_api_addrs = target_api_addrs
5787         self.target_ca_cert = target_ca_cert
5788
5789
5790
5791 class MigrationTargetInfo(Type):
5792     _toSchema = {'addrs': 'addrs', 'auth_tag': 'auth-tag', 'ca_cert': 'ca-cert', 'controller_tag': 'controller-tag', 'macaroons': 'macaroons', 'password': 'password'}
5793     _toPy = {'addrs': 'addrs', 'auth-tag': 'auth_tag', 'ca-cert': 'ca_cert', 'controller-tag': 'controller_tag', 'macaroons': 'macaroons', 'password': 'password'}
5794     def __init__(self, addrs=None, auth_tag=None, ca_cert=None, controller_tag=None, macaroons=None, password=None, **unknown_fields):
5795         '''
5796         addrs : typing.Sequence[str]
5797         auth_tag : str
5798         ca_cert : str
5799         controller_tag : str
5800         macaroons : str
5801         password : str
5802         '''
5803         self.addrs = addrs
5804         self.auth_tag = auth_tag
5805         self.ca_cert = ca_cert
5806         self.controller_tag = controller_tag
5807         self.macaroons = macaroons
5808         self.password = password
5809
5810
5811
5812 class MinionReport(Type):
5813     _toSchema = {'migration_id': 'migration-id', 'phase': 'phase', 'success': 'success'}
5814     _toPy = {'migration-id': 'migration_id', 'phase': 'phase', 'success': 'success'}
5815     def __init__(self, migration_id=None, phase=None, success=None, **unknown_fields):
5816         '''
5817         migration_id : str
5818         phase : str
5819         success : bool
5820         '''
5821         self.migration_id = migration_id
5822         self.phase = phase
5823         self.success = success
5824
5825
5826
5827 class MinionReports(Type):
5828     _toSchema = {'failed': 'failed', 'migration_id': 'migration-id', 'phase': 'phase', 'success_count': 'success-count', 'unknown_count': 'unknown-count', 'unknown_sample': 'unknown-sample'}
5829     _toPy = {'failed': 'failed', 'migration-id': 'migration_id', 'phase': 'phase', 'success-count': 'success_count', 'unknown-count': 'unknown_count', 'unknown-sample': 'unknown_sample'}
5830     def __init__(self, failed=None, migration_id=None, phase=None, success_count=None, unknown_count=None, unknown_sample=None, **unknown_fields):
5831         '''
5832         failed : typing.Sequence[str]
5833         migration_id : str
5834         phase : str
5835         success_count : int
5836         unknown_count : int
5837         unknown_sample : typing.Sequence[str]
5838         '''
5839         self.failed = failed
5840         self.migration_id = migration_id
5841         self.phase = phase
5842         self.success_count = success_count
5843         self.unknown_count = unknown_count
5844         self.unknown_sample = unknown_sample
5845
5846
5847
5848 class Model(Type):
5849     _toSchema = {'name': 'name', 'owner_tag': 'owner-tag', 'uuid': 'uuid'}
5850     _toPy = {'name': 'name', 'owner-tag': 'owner_tag', 'uuid': 'uuid'}
5851     def __init__(self, name=None, owner_tag=None, uuid=None, **unknown_fields):
5852         '''
5853         name : str
5854         owner_tag : str
5855         uuid : str
5856         '''
5857         self.name = name
5858         self.owner_tag = owner_tag
5859         self.uuid = uuid
5860
5861
5862
5863 class ModelAccess(Type):
5864     _toSchema = {'access': 'access', 'model': 'model'}
5865     _toPy = {'access': 'access', 'model': 'model'}
5866     def __init__(self, access=None, model=None, **unknown_fields):
5867         '''
5868         access : str
5869         model : str
5870         '''
5871         self.access = access
5872         self.model = model
5873
5874
5875
5876 class ModelArgs(Type):
5877     _toSchema = {'model_tag': 'model-tag'}
5878     _toPy = {'model-tag': 'model_tag'}
5879     def __init__(self, model_tag=None, **unknown_fields):
5880         '''
5881         model_tag : str
5882         '''
5883         self.model_tag = model_tag
5884
5885
5886
5887 class ModelBlockInfo(Type):
5888     _toSchema = {'blocks': 'blocks', 'model_uuid': 'model-uuid', 'name': 'name', 'owner_tag': 'owner-tag'}
5889     _toPy = {'blocks': 'blocks', 'model-uuid': 'model_uuid', 'name': 'name', 'owner-tag': 'owner_tag'}
5890     def __init__(self, blocks=None, model_uuid=None, name=None, owner_tag=None, **unknown_fields):
5891         '''
5892         blocks : typing.Sequence[str]
5893         model_uuid : str
5894         name : str
5895         owner_tag : str
5896         '''
5897         self.blocks = blocks
5898         self.model_uuid = model_uuid
5899         self.name = name
5900         self.owner_tag = owner_tag
5901
5902
5903
5904 class ModelBlockInfoList(Type):
5905     _toSchema = {'models': 'models'}
5906     _toPy = {'models': 'models'}
5907     def __init__(self, models=None, **unknown_fields):
5908         '''
5909         models : typing.Sequence[~ModelBlockInfo]
5910         '''
5911         self.models = [ModelBlockInfo.from_json(o) for o in models or []]
5912
5913
5914
5915 class ModelConfigResult(Type):
5916     _toSchema = {'config': 'config'}
5917     _toPy = {'config': 'config'}
5918     def __init__(self, config=None, **unknown_fields):
5919         '''
5920         config : typing.Mapping[str, typing.Any]
5921         '''
5922         self.config = config
5923
5924
5925
5926 class ModelConfigResults(Type):
5927     _toSchema = {'config': 'config'}
5928     _toPy = {'config': 'config'}
5929     def __init__(self, config=None, **unknown_fields):
5930         '''
5931         config : typing.Mapping[str, ~ConfigValue]
5932         '''
5933         self.config = config
5934
5935
5936
5937 class ModelCreateArgs(Type):
5938     _toSchema = {'cloud_tag': 'cloud-tag', 'config': 'config', 'credential': 'credential', 'name': 'name', 'owner_tag': 'owner-tag', 'region': 'region'}
5939     _toPy = {'cloud-tag': 'cloud_tag', 'config': 'config', 'credential': 'credential', 'name': 'name', 'owner-tag': 'owner_tag', 'region': 'region'}
5940     def __init__(self, cloud_tag=None, config=None, credential=None, name=None, owner_tag=None, region=None, **unknown_fields):
5941         '''
5942         cloud_tag : str
5943         config : typing.Mapping[str, typing.Any]
5944         credential : str
5945         name : str
5946         owner_tag : str
5947         region : str
5948         '''
5949         self.cloud_tag = cloud_tag
5950         self.config = config
5951         self.credential = credential
5952         self.name = name
5953         self.owner_tag = owner_tag
5954         self.region = region
5955
5956
5957
5958 class ModelCredential(Type):
5959     _toSchema = {'credential_tag': 'credential-tag', 'exists': 'exists', 'model_tag': 'model-tag', 'valid': 'valid'}
5960     _toPy = {'credential-tag': 'credential_tag', 'exists': 'exists', 'model-tag': 'model_tag', 'valid': 'valid'}
5961     def __init__(self, credential_tag=None, exists=None, model_tag=None, valid=None, **unknown_fields):
5962         '''
5963         credential_tag : str
5964         exists : bool
5965         model_tag : str
5966         valid : bool
5967         '''
5968         self.credential_tag = credential_tag
5969         self.exists = exists
5970         self.model_tag = model_tag
5971         self.valid = valid
5972
5973
5974
5975 class ModelDefaultValues(Type):
5976     _toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'config': 'config'}
5977     _toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'config': 'config'}
5978     def __init__(self, cloud_region=None, cloud_tag=None, config=None, **unknown_fields):
5979         '''
5980         cloud_region : str
5981         cloud_tag : str
5982         config : typing.Mapping[str, typing.Any]
5983         '''
5984         self.cloud_region = cloud_region
5985         self.cloud_tag = cloud_tag
5986         self.config = config
5987
5988
5989
5990 class ModelDefaults(Type):
5991     _toSchema = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
5992     _toPy = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
5993     def __init__(self, controller=None, default=None, regions=None, **unknown_fields):
5994         '''
5995         controller : typing.Mapping[str, typing.Any]
5996         default : typing.Mapping[str, typing.Any]
5997         regions : typing.Sequence[~RegionDefaults]
5998         '''
5999         self.controller = controller
6000         self.default = default
6001         self.regions = [RegionDefaults.from_json(o) for o in regions or []]
6002
6003
6004
6005 class ModelDefaultsResult(Type):
6006     _toSchema = {'config': 'config'}
6007     _toPy = {'config': 'config'}
6008     def __init__(self, config=None, **unknown_fields):
6009         '''
6010         config : typing.Mapping[str, ~ModelDefaults]
6011         '''
6012         self.config = config
6013
6014
6015
6016 class ModelEntityCount(Type):
6017     _toSchema = {'count': 'count', 'entity': 'entity'}
6018     _toPy = {'count': 'count', 'entity': 'entity'}
6019     def __init__(self, count=None, entity=None, **unknown_fields):
6020         '''
6021         count : int
6022         entity : str
6023         '''
6024         self.count = count
6025         self.entity = entity
6026
6027
6028
6029 class ModelFilesystemInfo(Type):
6030     _toSchema = {'detachable': 'detachable', 'id_': 'id', 'message': 'message', 'provider_id': 'provider-id', 'status': 'status'}
6031     _toPy = {'detachable': 'detachable', 'id': 'id_', 'message': 'message', 'provider-id': 'provider_id', 'status': 'status'}
6032     def __init__(self, detachable=None, id_=None, message=None, provider_id=None, status=None, **unknown_fields):
6033         '''
6034         detachable : bool
6035         id_ : str
6036         message : str
6037         provider_id : str
6038         status : str
6039         '''
6040         self.detachable = detachable
6041         self.id_ = id_
6042         self.message = message
6043         self.provider_id = provider_id
6044         self.status = status
6045
6046
6047
6048 class ModelInfo(Type):
6049     _toSchema = {'agent_version': 'agent-version', 'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'default_series': 'default-series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'sla': 'sla', 'status': 'status', 'type_': 'type', 'users': 'users', 'uuid': 'uuid'}
6050     _toPy = {'agent-version': 'agent_version', 'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'default-series': 'default_series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'sla': 'sla', 'status': 'status', 'type': 'type_', 'users': 'users', 'uuid': 'uuid'}
6051     def __init__(self, agent_version=None, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, default_series=None, life=None, machines=None, migration=None, name=None, owner_tag=None, provider_type=None, sla=None, status=None, type_=None, users=None, uuid=None, **unknown_fields):
6052         '''
6053         agent_version : Number
6054         cloud_credential_tag : str
6055         cloud_region : str
6056         cloud_tag : str
6057         controller_uuid : str
6058         default_series : str
6059         life : str
6060         machines : typing.Sequence[~ModelMachineInfo]
6061         migration : ModelMigrationStatus
6062         name : str
6063         owner_tag : str
6064         provider_type : str
6065         sla : ModelSLAInfo
6066         status : EntityStatus
6067         type_ : str
6068         users : typing.Sequence[~ModelUserInfo]
6069         uuid : str
6070         '''
6071         self.agent_version = Number.from_json(agent_version) if agent_version else None
6072         self.cloud_credential_tag = cloud_credential_tag
6073         self.cloud_region = cloud_region
6074         self.cloud_tag = cloud_tag
6075         self.controller_uuid = controller_uuid
6076         self.default_series = default_series
6077         self.life = life
6078         self.machines = [ModelMachineInfo.from_json(o) for o in machines or []]
6079         self.migration = ModelMigrationStatus.from_json(migration) if migration else None
6080         self.name = name
6081         self.owner_tag = owner_tag
6082         self.provider_type = provider_type
6083         self.sla = ModelSLAInfo.from_json(sla) if sla else None
6084         self.status = EntityStatus.from_json(status) if status else None
6085         self.type_ = type_
6086         self.users = [ModelUserInfo.from_json(o) for o in users or []]
6087         self.uuid = uuid
6088
6089
6090
6091 class ModelInfoResult(Type):
6092     _toSchema = {'error': 'error', 'result': 'result'}
6093     _toPy = {'error': 'error', 'result': 'result'}
6094     def __init__(self, error=None, result=None, **unknown_fields):
6095         '''
6096         error : Error
6097         result : ModelInfo
6098         '''
6099         self.error = Error.from_json(error) if error else None
6100         self.result = ModelInfo.from_json(result) if result else None
6101
6102
6103
6104 class ModelInfoResults(Type):
6105     _toSchema = {'results': 'results'}
6106     _toPy = {'results': 'results'}
6107     def __init__(self, results=None, **unknown_fields):
6108         '''
6109         results : typing.Sequence[~ModelInfoResult]
6110         '''
6111         self.results = [ModelInfoResult.from_json(o) for o in results or []]
6112
6113
6114
6115 class ModelInstanceTypesConstraint(Type):
6116     _toSchema = {'value': 'value'}
6117     _toPy = {'value': 'value'}
6118     def __init__(self, value=None, **unknown_fields):
6119         '''
6120         value : Value
6121         '''
6122         self.value = Value.from_json(value) if value else None
6123
6124
6125
6126 class ModelInstanceTypesConstraints(Type):
6127     _toSchema = {'constraints': 'constraints'}
6128     _toPy = {'constraints': 'constraints'}
6129     def __init__(self, constraints=None, **unknown_fields):
6130         '''
6131         constraints : typing.Sequence[~ModelInstanceTypesConstraint]
6132         '''
6133         self.constraints = [ModelInstanceTypesConstraint.from_json(o) for o in constraints or []]
6134
6135
6136
6137 class ModelMachineInfo(Type):
6138     _toSchema = {'hardware': 'hardware', 'has_vote': 'has-vote', 'id_': 'id', 'instance_id': 'instance-id', 'status': 'status', 'wants_vote': 'wants-vote'}
6139     _toPy = {'hardware': 'hardware', 'has-vote': 'has_vote', 'id': 'id_', 'instance-id': 'instance_id', 'status': 'status', 'wants-vote': 'wants_vote'}
6140     def __init__(self, hardware=None, has_vote=None, id_=None, instance_id=None, status=None, wants_vote=None, **unknown_fields):
6141         '''
6142         hardware : MachineHardware
6143         has_vote : bool
6144         id_ : str
6145         instance_id : str
6146         status : str
6147         wants_vote : bool
6148         '''
6149         self.hardware = MachineHardware.from_json(hardware) if hardware else None
6150         self.has_vote = has_vote
6151         self.id_ = id_
6152         self.instance_id = instance_id
6153         self.status = status
6154         self.wants_vote = wants_vote
6155
6156
6157
6158 class ModelMigrationStatus(Type):
6159     _toSchema = {'end': 'end', 'start': 'start', 'status': 'status'}
6160     _toPy = {'end': 'end', 'start': 'start', 'status': 'status'}
6161     def __init__(self, end=None, start=None, status=None, **unknown_fields):
6162         '''
6163         end : str
6164         start : str
6165         status : str
6166         '''
6167         self.end = end
6168         self.start = start
6169         self.status = status
6170
6171
6172
6173 class ModelResult(Type):
6174     _toSchema = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
6175     _toPy = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
6176     def __init__(self, error=None, name=None, uuid=None, **unknown_fields):
6177         '''
6178         error : Error
6179         name : str
6180         uuid : str
6181         '''
6182         self.error = Error.from_json(error) if error else None
6183         self.name = name
6184         self.uuid = uuid
6185
6186
6187
6188 class ModelSLA(Type):
6189     _toSchema = {'creds': 'creds', 'level': 'level'}
6190     _toPy = {'creds': 'creds', 'level': 'level'}
6191     def __init__(self, creds=None, level=None, **unknown_fields):
6192         '''
6193         creds : typing.Sequence[int]
6194         level : str
6195         '''
6196         self.creds = creds
6197         self.level = level
6198
6199
6200
6201 class ModelSLAInfo(Type):
6202     _toSchema = {'level': 'level', 'owner': 'owner'}
6203     _toPy = {'level': 'level', 'owner': 'owner'}
6204     def __init__(self, level=None, owner=None, **unknown_fields):
6205         '''
6206         level : str
6207         owner : str
6208         '''
6209         self.level = level
6210         self.owner = owner
6211
6212
6213
6214 class ModelSequencesResult(Type):
6215     _toSchema = {'sequences': 'sequences'}
6216     _toPy = {'sequences': 'sequences'}
6217     def __init__(self, sequences=None, **unknown_fields):
6218         '''
6219         sequences : typing.Mapping[str, int]
6220         '''
6221         self.sequences = sequences
6222
6223
6224
6225 class ModelSet(Type):
6226     _toSchema = {'config': 'config'}
6227     _toPy = {'config': 'config'}
6228     def __init__(self, config=None, **unknown_fields):
6229         '''
6230         config : typing.Mapping[str, typing.Any]
6231         '''
6232         self.config = config
6233
6234
6235
6236 class ModelStatus(Type):
6237     _toSchema = {'application_count': 'application-count', 'hosted_machine_count': 'hosted-machine-count', 'life': 'life', 'machines': 'machines', 'model_tag': 'model-tag', 'owner_tag': 'owner-tag'}
6238     _toPy = {'application-count': 'application_count', 'hosted-machine-count': 'hosted_machine_count', 'life': 'life', 'machines': 'machines', 'model-tag': 'model_tag', 'owner-tag': 'owner_tag'}
6239     def __init__(self, application_count=None, hosted_machine_count=None, life=None, machines=None, model_tag=None, owner_tag=None, **unknown_fields):
6240         '''
6241         application_count : int
6242         hosted_machine_count : int
6243         life : str
6244         machines : typing.Sequence[~ModelMachineInfo]
6245         model_tag : str
6246         owner_tag : str
6247         '''
6248         self.application_count = application_count
6249         self.hosted_machine_count = hosted_machine_count
6250         self.life = life
6251         self.machines = [ModelMachineInfo.from_json(o) for o in machines or []]
6252         self.model_tag = model_tag
6253         self.owner_tag = owner_tag
6254
6255
6256
6257 class ModelStatusInfo(Type):
6258     _toSchema = {'available_version': 'available-version', 'cloud_tag': 'cloud-tag', 'meter_status': 'meter-status', 'model_status': 'model-status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'type_': 'type', 'version': 'version'}
6259     _toPy = {'available-version': 'available_version', 'cloud-tag': 'cloud_tag', 'meter-status': 'meter_status', 'model-status': 'model_status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'type': 'type_', 'version': 'version'}
6260     def __init__(self, available_version=None, cloud_tag=None, meter_status=None, model_status=None, name=None, region=None, sla=None, type_=None, version=None, **unknown_fields):
6261         '''
6262         available_version : str
6263         cloud_tag : str
6264         meter_status : MeterStatus
6265         model_status : DetailedStatus
6266         name : str
6267         region : str
6268         sla : str
6269         type_ : str
6270         version : str
6271         '''
6272         self.available_version = available_version
6273         self.cloud_tag = cloud_tag
6274         self.meter_status = MeterStatus.from_json(meter_status) if meter_status else None
6275         self.model_status = DetailedStatus.from_json(model_status) if model_status else None
6276         self.name = name
6277         self.region = region
6278         self.sla = sla
6279         self.type_ = type_
6280         self.version = version
6281
6282
6283
6284 class ModelStatusResults(Type):
6285     _toSchema = {'models': 'models'}
6286     _toPy = {'models': 'models'}
6287     def __init__(self, models=None, **unknown_fields):
6288         '''
6289         models : typing.Sequence[~ModelStatus]
6290         '''
6291         self.models = [ModelStatus.from_json(o) for o in models or []]
6292
6293
6294
6295 class ModelSummariesRequest(Type):
6296     _toSchema = {'all_': 'all', 'user_tag': 'user-tag'}
6297     _toPy = {'all': 'all_', 'user-tag': 'user_tag'}
6298     def __init__(self, all_=None, user_tag=None, **unknown_fields):
6299         '''
6300         all_ : bool
6301         user_tag : str
6302         '''
6303         self.all_ = all_
6304         self.user_tag = user_tag
6305
6306
6307
6308 class ModelSummary(Type):
6309     _toSchema = {'agent_version': 'agent-version', 'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'counts': 'counts', 'default_series': 'default-series', 'last_connection': 'last-connection', 'life': 'life', 'migration': 'migration', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'sla': 'sla', 'status': 'status', 'type_': 'type', 'user_access': 'user-access', 'uuid': 'uuid'}
6310     _toPy = {'agent-version': 'agent_version', 'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'counts': 'counts', 'default-series': 'default_series', 'last-connection': 'last_connection', 'life': 'life', 'migration': 'migration', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'sla': 'sla', 'status': 'status', 'type': 'type_', 'user-access': 'user_access', 'uuid': 'uuid'}
6311     def __init__(self, agent_version=None, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, counts=None, default_series=None, last_connection=None, life=None, migration=None, name=None, owner_tag=None, provider_type=None, sla=None, status=None, type_=None, user_access=None, uuid=None, **unknown_fields):
6312         '''
6313         agent_version : Number
6314         cloud_credential_tag : str
6315         cloud_region : str
6316         cloud_tag : str
6317         controller_uuid : str
6318         counts : typing.Sequence[~ModelEntityCount]
6319         default_series : str
6320         last_connection : str
6321         life : str
6322         migration : ModelMigrationStatus
6323         name : str
6324         owner_tag : str
6325         provider_type : str
6326         sla : ModelSLAInfo
6327         status : EntityStatus
6328         type_ : str
6329         user_access : str
6330         uuid : str
6331         '''
6332         self.agent_version = Number.from_json(agent_version) if agent_version else None
6333         self.cloud_credential_tag = cloud_credential_tag
6334         self.cloud_region = cloud_region
6335         self.cloud_tag = cloud_tag
6336         self.controller_uuid = controller_uuid
6337         self.counts = [ModelEntityCount.from_json(o) for o in counts or []]
6338         self.default_series = default_series
6339         self.last_connection = last_connection
6340         self.life = life
6341         self.migration = ModelMigrationStatus.from_json(migration) if migration else None
6342         self.name = name
6343         self.owner_tag = owner_tag
6344         self.provider_type = provider_type
6345         self.sla = ModelSLAInfo.from_json(sla) if sla else None
6346         self.status = EntityStatus.from_json(status) if status else None
6347         self.type_ = type_
6348         self.user_access = user_access
6349         self.uuid = uuid
6350
6351
6352
6353 class ModelSummaryResult(Type):
6354     _toSchema = {'error': 'error', 'result': 'result'}
6355     _toPy = {'error': 'error', 'result': 'result'}
6356     def __init__(self, error=None, result=None, **unknown_fields):
6357         '''
6358         error : Error
6359         result : ModelSummary
6360         '''
6361         self.error = Error.from_json(error) if error else None
6362         self.result = ModelSummary.from_json(result) if result else None
6363
6364
6365
6366 class ModelSummaryResults(Type):
6367     _toSchema = {'results': 'results'}
6368     _toPy = {'results': 'results'}
6369     def __init__(self, results=None, **unknown_fields):
6370         '''
6371         results : typing.Sequence[~ModelSummaryResult]
6372         '''
6373         self.results = [ModelSummaryResult.from_json(o) for o in results or []]
6374
6375
6376
6377 class ModelTag(Type):
6378     _toSchema = {}
6379     _toPy = {}
6380     def __init__(self, **unknown_fields):
6381         '''
6382
6383         '''
6384         pass
6385
6386
6387
6388 class ModelUnset(Type):
6389     _toSchema = {'keys': 'keys'}
6390     _toPy = {'keys': 'keys'}
6391     def __init__(self, keys=None, **unknown_fields):
6392         '''
6393         keys : typing.Sequence[str]
6394         '''
6395         self.keys = keys
6396
6397
6398
6399 class ModelUnsetKeys(Type):
6400     _toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'keys': 'keys'}
6401     _toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'keys': 'keys'}
6402     def __init__(self, cloud_region=None, cloud_tag=None, keys=None, **unknown_fields):
6403         '''
6404         cloud_region : str
6405         cloud_tag : str
6406         keys : typing.Sequence[str]
6407         '''
6408         self.cloud_region = cloud_region
6409         self.cloud_tag = cloud_tag
6410         self.keys = keys
6411
6412
6413
6414 class ModelUserInfo(Type):
6415     _toSchema = {'access': 'access', 'display_name': 'display-name', 'last_connection': 'last-connection', 'user': 'user'}
6416     _toPy = {'access': 'access', 'display-name': 'display_name', 'last-connection': 'last_connection', 'user': 'user'}
6417     def __init__(self, access=None, display_name=None, last_connection=None, user=None, **unknown_fields):
6418         '''
6419         access : str
6420         display_name : str
6421         last_connection : str
6422         user : str
6423         '''
6424         self.access = access
6425         self.display_name = display_name
6426         self.last_connection = last_connection
6427         self.user = user
6428
6429
6430
6431 class ModelUserInfoResult(Type):
6432     _toSchema = {'error': 'error', 'result': 'result'}
6433     _toPy = {'error': 'error', 'result': 'result'}
6434     def __init__(self, error=None, result=None, **unknown_fields):
6435         '''
6436         error : Error
6437         result : ModelUserInfo
6438         '''
6439         self.error = Error.from_json(error) if error else None
6440         self.result = ModelUserInfo.from_json(result) if result else None
6441
6442
6443
6444 class ModelUserInfoResults(Type):
6445     _toSchema = {'results': 'results'}
6446     _toPy = {'results': 'results'}
6447     def __init__(self, results=None, **unknown_fields):
6448         '''
6449         results : typing.Sequence[~ModelUserInfoResult]
6450         '''
6451         self.results = [ModelUserInfoResult.from_json(o) for o in results or []]
6452
6453
6454
6455 class ModelVolumeInfo(Type):
6456     _toSchema = {'detachable': 'detachable', 'id_': 'id', 'message': 'message', 'provider_id': 'provider-id', 'status': 'status'}
6457     _toPy = {'detachable': 'detachable', 'id': 'id_', 'message': 'message', 'provider-id': 'provider_id', 'status': 'status'}
6458     def __init__(self, detachable=None, id_=None, message=None, provider_id=None, status=None, **unknown_fields):
6459         '''
6460         detachable : bool
6461         id_ : str
6462         message : str
6463         provider_id : str
6464         status : str
6465         '''
6466         self.detachable = detachable
6467         self.id_ = id_
6468         self.message = message
6469         self.provider_id = provider_id
6470         self.status = status
6471
6472
6473
6474 class ModifyCloudAccess(Type):
6475     _toSchema = {'access': 'access', 'action': 'action', 'cloud_tag': 'cloud-tag', 'user_tag': 'user-tag'}
6476     _toPy = {'access': 'access', 'action': 'action', 'cloud-tag': 'cloud_tag', 'user-tag': 'user_tag'}
6477     def __init__(self, access=None, action=None, cloud_tag=None, user_tag=None, **unknown_fields):
6478         '''
6479         access : str
6480         action : str
6481         cloud_tag : str
6482         user_tag : str
6483         '''
6484         self.access = access
6485         self.action = action
6486         self.cloud_tag = cloud_tag
6487         self.user_tag = user_tag
6488
6489
6490
6491 class ModifyCloudAccessRequest(Type):
6492     _toSchema = {'changes': 'changes'}
6493     _toPy = {'changes': 'changes'}
6494     def __init__(self, changes=None, **unknown_fields):
6495         '''
6496         changes : typing.Sequence[~ModifyCloudAccess]
6497         '''
6498         self.changes = [ModifyCloudAccess.from_json(o) for o in changes or []]
6499
6500
6501
6502 class ModifyControllerAccess(Type):
6503     _toSchema = {'access': 'access', 'action': 'action', 'user_tag': 'user-tag'}
6504     _toPy = {'access': 'access', 'action': 'action', 'user-tag': 'user_tag'}
6505     def __init__(self, access=None, action=None, user_tag=None, **unknown_fields):
6506         '''
6507         access : str
6508         action : str
6509         user_tag : str
6510         '''
6511         self.access = access
6512         self.action = action
6513         self.user_tag = user_tag
6514
6515
6516
6517 class ModifyControllerAccessRequest(Type):
6518     _toSchema = {'changes': 'changes'}
6519     _toPy = {'changes': 'changes'}
6520     def __init__(self, changes=None, **unknown_fields):
6521         '''
6522         changes : typing.Sequence[~ModifyControllerAccess]
6523         '''
6524         self.changes = [ModifyControllerAccess.from_json(o) for o in changes or []]
6525
6526
6527
6528 class ModifyModelAccess(Type):
6529     _toSchema = {'access': 'access', 'action': 'action', 'model_tag': 'model-tag', 'user_tag': 'user-tag'}
6530     _toPy = {'access': 'access', 'action': 'action', 'model-tag': 'model_tag', 'user-tag': 'user_tag'}
6531     def __init__(self, access=None, action=None, model_tag=None, user_tag=None, **unknown_fields):
6532         '''
6533         access : str
6534         action : str
6535         model_tag : str
6536         user_tag : str
6537         '''
6538         self.access = access
6539         self.action = action
6540         self.model_tag = model_tag
6541         self.user_tag = user_tag
6542
6543
6544
6545 class ModifyModelAccessRequest(Type):
6546     _toSchema = {'changes': 'changes'}
6547     _toPy = {'changes': 'changes'}
6548     def __init__(self, changes=None, **unknown_fields):
6549         '''
6550         changes : typing.Sequence[~ModifyModelAccess]
6551         '''
6552         self.changes = [ModifyModelAccess.from_json(o) for o in changes or []]
6553
6554
6555
6556 class ModifyOfferAccess(Type):
6557     _toSchema = {'access': 'access', 'action': 'action', 'offer_url': 'offer-url', 'user_tag': 'user-tag'}
6558     _toPy = {'access': 'access', 'action': 'action', 'offer-url': 'offer_url', 'user-tag': 'user_tag'}
6559     def __init__(self, access=None, action=None, offer_url=None, user_tag=None, **unknown_fields):
6560         '''
6561         access : str
6562         action : str
6563         offer_url : str
6564         user_tag : str
6565         '''
6566         self.access = access
6567         self.action = action
6568         self.offer_url = offer_url
6569         self.user_tag = user_tag
6570
6571
6572
6573 class ModifyOfferAccessRequest(Type):
6574     _toSchema = {'changes': 'changes'}
6575     _toPy = {'changes': 'changes'}
6576     def __init__(self, changes=None, **unknown_fields):
6577         '''
6578         changes : typing.Sequence[~ModifyOfferAccess]
6579         '''
6580         self.changes = [ModifyOfferAccess.from_json(o) for o in changes or []]
6581
6582
6583
6584 class ModifyUserSSHKeys(Type):
6585     _toSchema = {'ssh_keys': 'ssh-keys', 'user': 'user'}
6586     _toPy = {'ssh-keys': 'ssh_keys', 'user': 'user'}
6587     def __init__(self, ssh_keys=None, user=None, **unknown_fields):
6588         '''
6589         ssh_keys : typing.Sequence[str]
6590         user : str
6591         '''
6592         self.ssh_keys = ssh_keys
6593         self.user = user
6594
6595
6596
6597 class MongoUpgradeResults(Type):
6598     _toSchema = {'ha_members': 'ha-members', 'master': 'master', 'rs_members': 'rs-members'}
6599     _toPy = {'ha-members': 'ha_members', 'master': 'master', 'rs-members': 'rs_members'}
6600     def __init__(self, ha_members=None, master=None, rs_members=None, **unknown_fields):
6601         '''
6602         ha_members : typing.Sequence[~HAMember]
6603         master : HAMember
6604         rs_members : typing.Sequence[~Member]
6605         '''
6606         self.ha_members = [HAMember.from_json(o) for o in ha_members or []]
6607         self.master = HAMember.from_json(master) if master else None
6608         self.rs_members = [Member.from_json(o) for o in rs_members or []]
6609
6610
6611
6612 class MongoVersion(Type):
6613     _toSchema = {'engine': 'engine', 'major': 'major', 'minor': 'minor', 'patch': 'patch'}
6614     _toPy = {'engine': 'engine', 'major': 'major', 'minor': 'minor', 'patch': 'patch'}
6615     def __init__(self, engine=None, major=None, minor=None, patch=None, **unknown_fields):
6616         '''
6617         engine : str
6618         major : int
6619         minor : int
6620         patch : str
6621         '''
6622         self.engine = engine
6623         self.major = major
6624         self.minor = minor
6625         self.patch = patch
6626
6627
6628
6629 class NetworkConfig(Type):
6630     _toSchema = {'address': 'address', 'cidr': 'cidr', 'config_type': 'config-type', 'device_index': 'device-index', 'disabled': 'disabled', 'dns_search_domains': 'dns-search-domains', 'dns_servers': 'dns-servers', 'gateway_address': 'gateway-address', 'interface_name': 'interface-name', 'interface_type': 'interface-type', 'mac_address': 'mac-address', 'mtu': 'mtu', 'no_auto_start': 'no-auto-start', 'parent_interface_name': 'parent-interface-name', 'provider_address_id': 'provider-address-id', 'provider_id': 'provider-id', 'provider_space_id': 'provider-space-id', 'provider_subnet_id': 'provider-subnet-id', 'provider_vlan_id': 'provider-vlan-id', 'vlan_tag': 'vlan-tag'}
6631     _toPy = {'address': 'address', 'cidr': 'cidr', 'config-type': 'config_type', 'device-index': 'device_index', 'disabled': 'disabled', 'dns-search-domains': 'dns_search_domains', 'dns-servers': 'dns_servers', 'gateway-address': 'gateway_address', 'interface-name': 'interface_name', 'interface-type': 'interface_type', 'mac-address': 'mac_address', 'mtu': 'mtu', 'no-auto-start': 'no_auto_start', 'parent-interface-name': 'parent_interface_name', 'provider-address-id': 'provider_address_id', 'provider-id': 'provider_id', 'provider-space-id': 'provider_space_id', 'provider-subnet-id': 'provider_subnet_id', 'provider-vlan-id': 'provider_vlan_id', 'vlan-tag': 'vlan_tag'}
6632     def __init__(self, address=None, cidr=None, config_type=None, device_index=None, disabled=None, dns_search_domains=None, dns_servers=None, gateway_address=None, interface_name=None, interface_type=None, mac_address=None, mtu=None, no_auto_start=None, parent_interface_name=None, provider_address_id=None, provider_id=None, provider_space_id=None, provider_subnet_id=None, provider_vlan_id=None, vlan_tag=None, **unknown_fields):
6633         '''
6634         address : str
6635         cidr : str
6636         config_type : str
6637         device_index : int
6638         disabled : bool
6639         dns_search_domains : typing.Sequence[str]
6640         dns_servers : typing.Sequence[str]
6641         gateway_address : str
6642         interface_name : str
6643         interface_type : str
6644         mac_address : str
6645         mtu : int
6646         no_auto_start : bool
6647         parent_interface_name : str
6648         provider_address_id : str
6649         provider_id : str
6650         provider_space_id : str
6651         provider_subnet_id : str
6652         provider_vlan_id : str
6653         vlan_tag : int
6654         '''
6655         self.address = address
6656         self.cidr = cidr
6657         self.config_type = config_type
6658         self.device_index = device_index
6659         self.disabled = disabled
6660         self.dns_search_domains = dns_search_domains
6661         self.dns_servers = dns_servers
6662         self.gateway_address = gateway_address
6663         self.interface_name = interface_name
6664         self.interface_type = interface_type
6665         self.mac_address = mac_address
6666         self.mtu = mtu
6667         self.no_auto_start = no_auto_start
6668         self.parent_interface_name = parent_interface_name
6669         self.provider_address_id = provider_address_id
6670         self.provider_id = provider_id
6671         self.provider_space_id = provider_space_id
6672         self.provider_subnet_id = provider_subnet_id
6673         self.provider_vlan_id = provider_vlan_id
6674         self.vlan_tag = vlan_tag
6675
6676
6677
6678 class NetworkInfo(Type):
6679     _toSchema = {'addresses': 'addresses', 'interface_name': 'interface-name', 'mac_address': 'mac-address'}
6680     _toPy = {'addresses': 'addresses', 'interface-name': 'interface_name', 'mac-address': 'mac_address'}
6681     def __init__(self, addresses=None, interface_name=None, mac_address=None, **unknown_fields):
6682         '''
6683         addresses : typing.Sequence[~InterfaceAddress]
6684         interface_name : str
6685         mac_address : str
6686         '''
6687         self.addresses = [InterfaceAddress.from_json(o) for o in addresses or []]
6688         self.interface_name = interface_name
6689         self.mac_address = mac_address
6690
6691
6692
6693 class NetworkInfoParams(Type):
6694     _toSchema = {'bindings': 'bindings', 'unit': 'unit'}
6695     _toPy = {'bindings': 'bindings', 'unit': 'unit'}
6696     def __init__(self, bindings=None, unit=None, **unknown_fields):
6697         '''
6698         bindings : typing.Sequence[str]
6699         unit : str
6700         '''
6701         self.bindings = bindings
6702         self.unit = unit
6703
6704
6705
6706 class NetworkInfoResult(Type):
6707     _toSchema = {'error': 'error', 'network_info': 'network-info'}
6708     _toPy = {'error': 'error', 'network-info': 'network_info'}
6709     def __init__(self, error=None, network_info=None, **unknown_fields):
6710         '''
6711         error : Error
6712         network_info : typing.Sequence[~NetworkInfo]
6713         '''
6714         self.error = Error.from_json(error) if error else None
6715         self.network_info = [NetworkInfo.from_json(o) for o in network_info or []]
6716
6717
6718
6719 class NetworkInfoResults(Type):
6720     _toSchema = {'results': 'results'}
6721     _toPy = {'results': 'results'}
6722     def __init__(self, results=None, **unknown_fields):
6723         '''
6724         results : typing.Mapping[str, ~NetworkInfoResult]
6725         '''
6726         self.results = results
6727
6728
6729
6730 class NetworkInterface(Type):
6731     _toSchema = {'dns_nameservers': 'dns-nameservers', 'gateway': 'gateway', 'ip_addresses': 'ip-addresses', 'is_up': 'is-up', 'mac_address': 'mac-address', 'space': 'space'}
6732     _toPy = {'dns-nameservers': 'dns_nameservers', 'gateway': 'gateway', 'ip-addresses': 'ip_addresses', 'is-up': 'is_up', 'mac-address': 'mac_address', 'space': 'space'}
6733     def __init__(self, dns_nameservers=None, gateway=None, ip_addresses=None, is_up=None, mac_address=None, space=None, **unknown_fields):
6734         '''
6735         dns_nameservers : typing.Sequence[str]
6736         gateway : str
6737         ip_addresses : typing.Sequence[str]
6738         is_up : bool
6739         mac_address : str
6740         space : str
6741         '''
6742         self.dns_nameservers = dns_nameservers
6743         self.gateway = gateway
6744         self.ip_addresses = ip_addresses
6745         self.is_up = is_up
6746         self.mac_address = mac_address
6747         self.space = space
6748
6749
6750
6751 class NetworkRoute(Type):
6752     _toSchema = {'destination_cidr': 'destination-cidr', 'gateway_ip': 'gateway-ip', 'metric': 'metric'}
6753     _toPy = {'destination-cidr': 'destination_cidr', 'gateway-ip': 'gateway_ip', 'metric': 'metric'}
6754     def __init__(self, destination_cidr=None, gateway_ip=None, metric=None, **unknown_fields):
6755         '''
6756         destination_cidr : str
6757         gateway_ip : str
6758         metric : int
6759         '''
6760         self.destination_cidr = destination_cidr
6761         self.gateway_ip = gateway_ip
6762         self.metric = metric
6763
6764
6765
6766 class NotifyWatchResult(Type):
6767     _toSchema = {'error': 'error', 'notifywatcherid': 'NotifyWatcherId'}
6768     _toPy = {'NotifyWatcherId': 'notifywatcherid', 'error': 'error'}
6769     def __init__(self, notifywatcherid=None, error=None, **unknown_fields):
6770         '''
6771         notifywatcherid : str
6772         error : Error
6773         '''
6774         self.notifywatcherid = notifywatcherid
6775         self.error = Error.from_json(error) if error else None
6776
6777
6778
6779 class NotifyWatchResults(Type):
6780     _toSchema = {'results': 'results'}
6781     _toPy = {'results': 'results'}
6782     def __init__(self, results=None, **unknown_fields):
6783         '''
6784         results : typing.Sequence[~NotifyWatchResult]
6785         '''
6786         self.results = [NotifyWatchResult.from_json(o) for o in results or []]
6787
6788
6789
6790 class Number(Type):
6791     _toSchema = {'build': 'Build', 'major': 'Major', 'minor': 'Minor', 'patch': 'Patch', 'tag': 'Tag'}
6792     _toPy = {'Build': 'build', 'Major': 'major', 'Minor': 'minor', 'Patch': 'patch', 'Tag': 'tag'}
6793     def __init__(self, build=None, major=None, minor=None, patch=None, tag=None, **unknown_fields):
6794         '''
6795         build : int
6796         major : int
6797         minor : int
6798         patch : int
6799         tag : str
6800         '''
6801         self.build = build
6802         self.major = major
6803         self.minor = minor
6804         self.patch = patch
6805         self.tag = tag
6806
6807
6808
6809 class OfferArg(Type):
6810     _toSchema = {'macaroons': 'macaroons', 'offer_uuid': 'offer-uuid'}
6811     _toPy = {'macaroons': 'macaroons', 'offer-uuid': 'offer_uuid'}
6812     def __init__(self, macaroons=None, offer_uuid=None, **unknown_fields):
6813         '''
6814         macaroons : typing.Sequence[~Macaroon]
6815         offer_uuid : str
6816         '''
6817         self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
6818         self.offer_uuid = offer_uuid
6819
6820
6821
6822 class OfferArgs(Type):
6823     _toSchema = {'args': 'args'}
6824     _toPy = {'args': 'args'}
6825     def __init__(self, args=None, **unknown_fields):
6826         '''
6827         args : typing.Sequence[~OfferArg]
6828         '''
6829         self.args = [OfferArg.from_json(o) for o in args or []]
6830
6831
6832
6833 class OfferConnection(Type):
6834     _toSchema = {'endpoint': 'endpoint', 'ingress_subnets': 'ingress-subnets', 'relation_id': 'relation-id', 'source_model_tag': 'source-model-tag', 'status': 'status', 'username': 'username'}
6835     _toPy = {'endpoint': 'endpoint', 'ingress-subnets': 'ingress_subnets', 'relation-id': 'relation_id', 'source-model-tag': 'source_model_tag', 'status': 'status', 'username': 'username'}
6836     def __init__(self, endpoint=None, ingress_subnets=None, relation_id=None, source_model_tag=None, status=None, username=None, **unknown_fields):
6837         '''
6838         endpoint : str
6839         ingress_subnets : typing.Sequence[str]
6840         relation_id : int
6841         source_model_tag : str
6842         status : EntityStatus
6843         username : str
6844         '''
6845         self.endpoint = endpoint
6846         self.ingress_subnets = ingress_subnets
6847         self.relation_id = relation_id
6848         self.source_model_tag = source_model_tag
6849         self.status = EntityStatus.from_json(status) if status else None
6850         self.username = username
6851
6852
6853
6854 class OfferFilter(Type):
6855     _toSchema = {'allowed_users': 'allowed-users', 'application_description': 'application-description', 'application_name': 'application-name', 'application_user': 'application-user', 'connected_users': 'connected-users', 'endpoints': 'endpoints', 'model_name': 'model-name', 'offer_name': 'offer-name', 'owner_name': 'owner-name'}
6856     _toPy = {'allowed-users': 'allowed_users', 'application-description': 'application_description', 'application-name': 'application_name', 'application-user': 'application_user', 'connected-users': 'connected_users', 'endpoints': 'endpoints', 'model-name': 'model_name', 'offer-name': 'offer_name', 'owner-name': 'owner_name'}
6857     def __init__(self, allowed_users=None, application_description=None, application_name=None, application_user=None, connected_users=None, endpoints=None, model_name=None, offer_name=None, owner_name=None, **unknown_fields):
6858         '''
6859         allowed_users : typing.Sequence[str]
6860         application_description : str
6861         application_name : str
6862         application_user : str
6863         connected_users : typing.Sequence[str]
6864         endpoints : typing.Sequence[~EndpointFilterAttributes]
6865         model_name : str
6866         offer_name : str
6867         owner_name : str
6868         '''
6869         self.allowed_users = allowed_users
6870         self.application_description = application_description
6871         self.application_name = application_name
6872         self.application_user = application_user
6873         self.connected_users = connected_users
6874         self.endpoints = [EndpointFilterAttributes.from_json(o) for o in endpoints or []]
6875         self.model_name = model_name
6876         self.offer_name = offer_name
6877         self.owner_name = owner_name
6878
6879
6880
6881 class OfferFilters(Type):
6882     _toSchema = {'filters': 'Filters'}
6883     _toPy = {'Filters': 'filters'}
6884     def __init__(self, filters=None, **unknown_fields):
6885         '''
6886         filters : typing.Sequence[~OfferFilter]
6887         '''
6888         self.filters = [OfferFilter.from_json(o) for o in filters or []]
6889
6890
6891
6892 class OfferStatusChange(Type):
6893     _toSchema = {'offer_name': 'offer-name', 'status': 'status'}
6894     _toPy = {'offer-name': 'offer_name', 'status': 'status'}
6895     def __init__(self, offer_name=None, status=None, **unknown_fields):
6896         '''
6897         offer_name : str
6898         status : EntityStatus
6899         '''
6900         self.offer_name = offer_name
6901         self.status = EntityStatus.from_json(status) if status else None
6902
6903
6904
6905 class OfferStatusWatchResult(Type):
6906     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
6907     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
6908     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
6909         '''
6910         changes : typing.Sequence[~OfferStatusChange]
6911         error : Error
6912         watcher_id : str
6913         '''
6914         self.changes = [OfferStatusChange.from_json(o) for o in changes or []]
6915         self.error = Error.from_json(error) if error else None
6916         self.watcher_id = watcher_id
6917
6918
6919
6920 class OfferStatusWatchResults(Type):
6921     _toSchema = {'results': 'results'}
6922     _toPy = {'results': 'results'}
6923     def __init__(self, results=None, **unknown_fields):
6924         '''
6925         results : typing.Sequence[~OfferStatusWatchResult]
6926         '''
6927         self.results = [OfferStatusWatchResult.from_json(o) for o in results or []]
6928
6929
6930
6931 class OfferURLs(Type):
6932     _toSchema = {'offer_urls': 'offer-urls'}
6933     _toPy = {'offer-urls': 'offer_urls'}
6934     def __init__(self, offer_urls=None, **unknown_fields):
6935         '''
6936         offer_urls : typing.Sequence[str]
6937         '''
6938         self.offer_urls = offer_urls
6939
6940
6941
6942 class OfferUserDetails(Type):
6943     _toSchema = {'access': 'access', 'display_name': 'display-name', 'user': 'user'}
6944     _toPy = {'access': 'access', 'display-name': 'display_name', 'user': 'user'}
6945     def __init__(self, access=None, display_name=None, user=None, **unknown_fields):
6946         '''
6947         access : str
6948         display_name : str
6949         user : str
6950         '''
6951         self.access = access
6952         self.display_name = display_name
6953         self.user = user
6954
6955
6956
6957 class OperatorProvisioningInfo(Type):
6958     _toSchema = {'api_addresses': 'api-addresses', 'charm_storage': 'charm-storage', 'image_path': 'image-path', 'tags': 'tags', 'version': 'version'}
6959     _toPy = {'api-addresses': 'api_addresses', 'charm-storage': 'charm_storage', 'image-path': 'image_path', 'tags': 'tags', 'version': 'version'}
6960     def __init__(self, api_addresses=None, charm_storage=None, image_path=None, tags=None, version=None, **unknown_fields):
6961         '''
6962         api_addresses : typing.Sequence[str]
6963         charm_storage : KubernetesFilesystemParams
6964         image_path : str
6965         tags : typing.Mapping[str, str]
6966         version : Number
6967         '''
6968         self.api_addresses = api_addresses
6969         self.charm_storage = KubernetesFilesystemParams.from_json(charm_storage) if charm_storage else None
6970         self.image_path = image_path
6971         self.tags = tags
6972         self.version = Number.from_json(version) if version else None
6973
6974
6975
6976 class Payload(Type):
6977     _toSchema = {'class_': 'class', 'id_': 'id', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type_': 'type', 'unit': 'unit'}
6978     _toPy = {'class': 'class_', 'id': 'id_', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type': 'type_', 'unit': 'unit'}
6979     def __init__(self, class_=None, id_=None, labels=None, machine=None, status=None, type_=None, unit=None, **unknown_fields):
6980         '''
6981         class_ : str
6982         id_ : str
6983         labels : typing.Sequence[str]
6984         machine : str
6985         status : str
6986         type_ : str
6987         unit : str
6988         '''
6989         self.class_ = class_
6990         self.id_ = id_
6991         self.labels = labels
6992         self.machine = machine
6993         self.status = status
6994         self.type_ = type_
6995         self.unit = unit
6996
6997
6998
6999 class PayloadListArgs(Type):
7000     _toSchema = {'patterns': 'patterns'}
7001     _toPy = {'patterns': 'patterns'}
7002     def __init__(self, patterns=None, **unknown_fields):
7003         '''
7004         patterns : typing.Sequence[str]
7005         '''
7006         self.patterns = patterns
7007
7008
7009
7010 class PayloadListResults(Type):
7011     _toSchema = {'results': 'results'}
7012     _toPy = {'results': 'results'}
7013     def __init__(self, results=None, **unknown_fields):
7014         '''
7015         results : typing.Sequence[~Payload]
7016         '''
7017         self.results = [Payload.from_json(o) for o in results or []]
7018
7019
7020
7021 class PayloadResult(Type):
7022     _toSchema = {'entity': 'Entity', 'error': 'error', 'not_found': 'not-found', 'payload': 'payload'}
7023     _toPy = {'Entity': 'entity', 'error': 'error', 'not-found': 'not_found', 'payload': 'payload'}
7024     def __init__(self, entity=None, error=None, not_found=None, payload=None, **unknown_fields):
7025         '''
7026         entity : Entity
7027         error : Error
7028         not_found : bool
7029         payload : Payload
7030         '''
7031         self.entity = Entity.from_json(entity) if entity else None
7032         self.error = Error.from_json(error) if error else None
7033         self.not_found = not_found
7034         self.payload = Payload.from_json(payload) if payload else None
7035
7036
7037
7038 class PayloadResults(Type):
7039     _toSchema = {'results': 'results'}
7040     _toPy = {'results': 'results'}
7041     def __init__(self, results=None, **unknown_fields):
7042         '''
7043         results : typing.Sequence[~PayloadResult]
7044         '''
7045         self.results = [PayloadResult.from_json(o) for o in results or []]
7046
7047
7048
7049 class PhaseResult(Type):
7050     _toSchema = {'error': 'error', 'phase': 'phase'}
7051     _toPy = {'error': 'error', 'phase': 'phase'}
7052     def __init__(self, error=None, phase=None, **unknown_fields):
7053         '''
7054         error : Error
7055         phase : str
7056         '''
7057         self.error = Error.from_json(error) if error else None
7058         self.phase = phase
7059
7060
7061
7062 class PhaseResults(Type):
7063     _toSchema = {'results': 'results'}
7064     _toPy = {'results': 'results'}
7065     def __init__(self, results=None, **unknown_fields):
7066         '''
7067         results : typing.Sequence[~PhaseResult]
7068         '''
7069         self.results = [PhaseResult.from_json(o) for o in results or []]
7070
7071
7072
7073 class PinApplicationResult(Type):
7074     _toSchema = {'application_name': 'application-name', 'error': 'error'}
7075     _toPy = {'application-name': 'application_name', 'error': 'error'}
7076     def __init__(self, application_name=None, error=None, **unknown_fields):
7077         '''
7078         application_name : str
7079         error : Error
7080         '''
7081         self.application_name = application_name
7082         self.error = Error.from_json(error) if error else None
7083
7084
7085
7086 class PinApplicationsResults(Type):
7087     _toSchema = {'results': 'results'}
7088     _toPy = {'results': 'results'}
7089     def __init__(self, results=None, **unknown_fields):
7090         '''
7091         results : typing.Sequence[~PinApplicationResult]
7092         '''
7093         self.results = [PinApplicationResult.from_json(o) for o in results or []]
7094
7095
7096
7097 class PinnedLeadershipResult(Type):
7098     _toSchema = {'result': 'result'}
7099     _toPy = {'result': 'result'}
7100     def __init__(self, result=None, **unknown_fields):
7101         '''
7102         result : typing.Sequence[str]
7103         '''
7104         self.result = result
7105
7106
7107
7108 class Placement(Type):
7109     _toSchema = {'directive': 'directive', 'scope': 'scope'}
7110     _toPy = {'directive': 'directive', 'scope': 'scope'}
7111     def __init__(self, directive=None, scope=None, **unknown_fields):
7112         '''
7113         directive : str
7114         scope : str
7115         '''
7116         self.directive = directive
7117         self.scope = scope
7118
7119
7120
7121 class PortRange(Type):
7122     _toSchema = {'from_port': 'from-port', 'protocol': 'protocol', 'to_port': 'to-port'}
7123     _toPy = {'from-port': 'from_port', 'protocol': 'protocol', 'to-port': 'to_port'}
7124     def __init__(self, from_port=None, protocol=None, to_port=None, **unknown_fields):
7125         '''
7126         from_port : int
7127         protocol : str
7128         to_port : int
7129         '''
7130         self.from_port = from_port
7131         self.protocol = protocol
7132         self.to_port = to_port
7133
7134
7135
7136 class PrivateAddress(Type):
7137     _toSchema = {'target': 'target'}
7138     _toPy = {'target': 'target'}
7139     def __init__(self, target=None, **unknown_fields):
7140         '''
7141         target : str
7142         '''
7143         self.target = target
7144
7145
7146
7147 class PrivateAddressResults(Type):
7148     _toSchema = {'private_address': 'private-address'}
7149     _toPy = {'private-address': 'private_address'}
7150     def __init__(self, private_address=None, **unknown_fields):
7151         '''
7152         private_address : str
7153         '''
7154         self.private_address = private_address
7155
7156
7157
7158 class ProfileChangeResult(Type):
7159     _toSchema = {'error': 'error', 'new_profile_name': 'new-profile-name', 'old_profile_name': 'old-profile-name', 'profile': 'profile', 'subordinate': 'subordinate'}
7160     _toPy = {'error': 'error', 'new-profile-name': 'new_profile_name', 'old-profile-name': 'old_profile_name', 'profile': 'profile', 'subordinate': 'subordinate'}
7161     def __init__(self, error=None, new_profile_name=None, old_profile_name=None, profile=None, subordinate=None, **unknown_fields):
7162         '''
7163         error : Error
7164         new_profile_name : str
7165         old_profile_name : str
7166         profile : CharmLXDProfile
7167         subordinate : bool
7168         '''
7169         self.error = Error.from_json(error) if error else None
7170         self.new_profile_name = new_profile_name
7171         self.old_profile_name = old_profile_name
7172         self.profile = CharmLXDProfile.from_json(profile) if profile else None
7173         self.subordinate = subordinate
7174
7175
7176
7177 class ProfileChangeResults(Type):
7178     _toSchema = {'results': 'results'}
7179     _toPy = {'results': 'results'}
7180     def __init__(self, results=None, **unknown_fields):
7181         '''
7182         results : typing.Sequence[~ProfileChangeResult]
7183         '''
7184         self.results = [ProfileChangeResult.from_json(o) for o in results or []]
7185
7186
7187
7188 class ProviderInterfaceInfo(Type):
7189     _toSchema = {'interface_name': 'interface-name', 'mac_address': 'mac-address', 'provider_id': 'provider-id'}
7190     _toPy = {'interface-name': 'interface_name', 'mac-address': 'mac_address', 'provider-id': 'provider_id'}
7191     def __init__(self, interface_name=None, mac_address=None, provider_id=None, **unknown_fields):
7192         '''
7193         interface_name : str
7194         mac_address : str
7195         provider_id : str
7196         '''
7197         self.interface_name = interface_name
7198         self.mac_address = mac_address
7199         self.provider_id = provider_id
7200
7201
7202
7203 class ProviderInterfaceInfoResult(Type):
7204     _toSchema = {'error': 'error', 'interfaces': 'interfaces', 'machine_tag': 'machine-tag'}
7205     _toPy = {'error': 'error', 'interfaces': 'interfaces', 'machine-tag': 'machine_tag'}
7206     def __init__(self, error=None, interfaces=None, machine_tag=None, **unknown_fields):
7207         '''
7208         error : Error
7209         interfaces : typing.Sequence[~ProviderInterfaceInfo]
7210         machine_tag : str
7211         '''
7212         self.error = Error.from_json(error) if error else None
7213         self.interfaces = [ProviderInterfaceInfo.from_json(o) for o in interfaces or []]
7214         self.machine_tag = machine_tag
7215
7216
7217
7218 class ProviderInterfaceInfoResults(Type):
7219     _toSchema = {'results': 'results'}
7220     _toPy = {'results': 'results'}
7221     def __init__(self, results=None, **unknown_fields):
7222         '''
7223         results : typing.Sequence[~ProviderInterfaceInfoResult]
7224         '''
7225         self.results = [ProviderInterfaceInfoResult.from_json(o) for o in results or []]
7226
7227
7228
7229 class ProviderSpace(Type):
7230     _toSchema = {'error': 'error', 'name': 'name', 'provider_id': 'provider-id', 'subnets': 'subnets'}
7231     _toPy = {'error': 'error', 'name': 'name', 'provider-id': 'provider_id', 'subnets': 'subnets'}
7232     def __init__(self, error=None, name=None, provider_id=None, subnets=None, **unknown_fields):
7233         '''
7234         error : Error
7235         name : str
7236         provider_id : str
7237         subnets : typing.Sequence[~Subnet]
7238         '''
7239         self.error = Error.from_json(error) if error else None
7240         self.name = name
7241         self.provider_id = provider_id
7242         self.subnets = [Subnet.from_json(o) for o in subnets or []]
7243
7244
7245
7246 class ProvisioningInfo(Type):
7247     _toSchema = {'constraints': 'constraints', 'controller_config': 'controller-config', 'endpoint_bindings': 'endpoint-bindings', 'image_metadata': 'image-metadata', 'jobs': 'jobs', 'placement': 'placement', 'series': 'series', 'subnets_to_zones': 'subnets-to-zones', 'tags': 'tags', 'volumes': 'volumes'}
7248     _toPy = {'constraints': 'constraints', 'controller-config': 'controller_config', 'endpoint-bindings': 'endpoint_bindings', 'image-metadata': 'image_metadata', 'jobs': 'jobs', 'placement': 'placement', 'series': 'series', 'subnets-to-zones': 'subnets_to_zones', 'tags': 'tags', 'volumes': 'volumes'}
7249     def __init__(self, constraints=None, controller_config=None, endpoint_bindings=None, image_metadata=None, jobs=None, placement=None, series=None, subnets_to_zones=None, tags=None, volumes=None, **unknown_fields):
7250         '''
7251         constraints : Value
7252         controller_config : typing.Mapping[str, typing.Any]
7253         endpoint_bindings : typing.Mapping[str, str]
7254         image_metadata : typing.Sequence[~CloudImageMetadata]
7255         jobs : typing.Sequence[str]
7256         placement : str
7257         series : str
7258         subnets_to_zones : typing.Sequence[str]
7259         tags : typing.Mapping[str, str]
7260         volumes : typing.Sequence[~VolumeParams]
7261         '''
7262         self.constraints = Value.from_json(constraints) if constraints else None
7263         self.controller_config = controller_config
7264         self.endpoint_bindings = endpoint_bindings
7265         self.image_metadata = [CloudImageMetadata.from_json(o) for o in image_metadata or []]
7266         self.jobs = jobs
7267         self.placement = placement
7268         self.series = series
7269         self.subnets_to_zones = subnets_to_zones
7270         self.tags = tags
7271         self.volumes = [VolumeParams.from_json(o) for o in volumes or []]
7272
7273
7274
7275 class ProvisioningInfoResult(Type):
7276     _toSchema = {'error': 'error', 'result': 'result'}
7277     _toPy = {'error': 'error', 'result': 'result'}
7278     def __init__(self, error=None, result=None, **unknown_fields):
7279         '''
7280         error : Error
7281         result : ProvisioningInfo
7282         '''
7283         self.error = Error.from_json(error) if error else None
7284         self.result = ProvisioningInfo.from_json(result) if result else None
7285
7286
7287
7288 class ProvisioningInfoResults(Type):
7289     _toSchema = {'results': 'results'}
7290     _toPy = {'results': 'results'}
7291     def __init__(self, results=None, **unknown_fields):
7292         '''
7293         results : typing.Sequence[~ProvisioningInfoResult]
7294         '''
7295         self.results = [ProvisioningInfoResult.from_json(o) for o in results or []]
7296
7297
7298
7299 class ProvisioningScriptParams(Type):
7300     _toSchema = {'data_dir': 'data-dir', 'disable_package_commands': 'disable-package-commands', 'machine_id': 'machine-id', 'nonce': 'nonce'}
7301     _toPy = {'data-dir': 'data_dir', 'disable-package-commands': 'disable_package_commands', 'machine-id': 'machine_id', 'nonce': 'nonce'}
7302     def __init__(self, data_dir=None, disable_package_commands=None, machine_id=None, nonce=None, **unknown_fields):
7303         '''
7304         data_dir : str
7305         disable_package_commands : bool
7306         machine_id : str
7307         nonce : str
7308         '''
7309         self.data_dir = data_dir
7310         self.disable_package_commands = disable_package_commands
7311         self.machine_id = machine_id
7312         self.nonce = nonce
7313
7314
7315
7316 class ProvisioningScriptResult(Type):
7317     _toSchema = {'script': 'script'}
7318     _toPy = {'script': 'script'}
7319     def __init__(self, script=None, **unknown_fields):
7320         '''
7321         script : str
7322         '''
7323         self.script = script
7324
7325
7326
7327 class ProxyConfig(Type):
7328     _toSchema = {'ftp': 'ftp', 'http': 'http', 'https': 'https', 'no_proxy': 'no-proxy'}
7329     _toPy = {'ftp': 'ftp', 'http': 'http', 'https': 'https', 'no-proxy': 'no_proxy'}
7330     def __init__(self, ftp=None, http=None, https=None, no_proxy=None, **unknown_fields):
7331         '''
7332         ftp : str
7333         http : str
7334         https : str
7335         no_proxy : str
7336         '''
7337         self.ftp = ftp
7338         self.http = http
7339         self.https = https
7340         self.no_proxy = no_proxy
7341
7342
7343
7344 class ProxyConfigResult(Type):
7345     _toSchema = {'apt_proxy_settings': 'apt-proxy-settings', 'error': 'error', 'proxy_settings': 'proxy-settings'}
7346     _toPy = {'apt-proxy-settings': 'apt_proxy_settings', 'error': 'error', 'proxy-settings': 'proxy_settings'}
7347     def __init__(self, apt_proxy_settings=None, error=None, proxy_settings=None, **unknown_fields):
7348         '''
7349         apt_proxy_settings : ProxyConfig
7350         error : Error
7351         proxy_settings : ProxyConfig
7352         '''
7353         self.apt_proxy_settings = ProxyConfig.from_json(apt_proxy_settings) if apt_proxy_settings else None
7354         self.error = Error.from_json(error) if error else None
7355         self.proxy_settings = ProxyConfig.from_json(proxy_settings) if proxy_settings else None
7356
7357
7358
7359 class ProxyConfigResults(Type):
7360     _toSchema = {'results': 'results'}
7361     _toPy = {'results': 'results'}
7362     def __init__(self, results=None, **unknown_fields):
7363         '''
7364         results : typing.Sequence[~ProxyConfigResult]
7365         '''
7366         self.results = [ProxyConfigResult.from_json(o) for o in results or []]
7367
7368
7369
7370 class PublicAddress(Type):
7371     _toSchema = {'target': 'target'}
7372     _toPy = {'target': 'target'}
7373     def __init__(self, target=None, **unknown_fields):
7374         '''
7375         target : str
7376         '''
7377         self.target = target
7378
7379
7380
7381 class PublicAddressResults(Type):
7382     _toSchema = {'public_address': 'public-address'}
7383     _toPy = {'public-address': 'public_address'}
7384     def __init__(self, public_address=None, **unknown_fields):
7385         '''
7386         public_address : str
7387         '''
7388         self.public_address = public_address
7389
7390
7391
7392 class QueryApplicationOffersResults(Type):
7393     _toSchema = {'results': 'results'}
7394     _toPy = {'results': 'results'}
7395     def __init__(self, results=None, **unknown_fields):
7396         '''
7397         results : typing.Sequence[~ApplicationOfferAdminDetails]
7398         '''
7399         self.results = [ApplicationOfferAdminDetails.from_json(o) for o in results or []]
7400
7401
7402
7403 class RebootActionResult(Type):
7404     _toSchema = {'error': 'error', 'result': 'result'}
7405     _toPy = {'error': 'error', 'result': 'result'}
7406     def __init__(self, error=None, result=None, **unknown_fields):
7407         '''
7408         error : Error
7409         result : str
7410         '''
7411         self.error = Error.from_json(error) if error else None
7412         self.result = result
7413
7414
7415
7416 class RebootActionResults(Type):
7417     _toSchema = {'results': 'results'}
7418     _toPy = {'results': 'results'}
7419     def __init__(self, results=None, **unknown_fields):
7420         '''
7421         results : typing.Sequence[~RebootActionResult]
7422         '''
7423         self.results = [RebootActionResult.from_json(o) for o in results or []]
7424
7425
7426
7427 class RegionDefaults(Type):
7428     _toSchema = {'region_name': 'region-name', 'value': 'value'}
7429     _toPy = {'region-name': 'region_name', 'value': 'value'}
7430     def __init__(self, region_name=None, value=None, **unknown_fields):
7431         '''
7432         region_name : str
7433         value : typing.Mapping[str, typing.Any]
7434         '''
7435         self.region_name = region_name
7436         self.value = value
7437
7438
7439
7440 class RegisterRemoteRelationArg(Type):
7441     _toSchema = {'application_token': 'application-token', 'local_endpoint_name': 'local-endpoint-name', 'macaroons': 'macaroons', 'offer_uuid': 'offer-uuid', 'relation_token': 'relation-token', 'remote_endpoint': 'remote-endpoint', 'remote_space': 'remote-space', 'source_model_tag': 'source-model-tag'}
7442     _toPy = {'application-token': 'application_token', 'local-endpoint-name': 'local_endpoint_name', 'macaroons': 'macaroons', 'offer-uuid': 'offer_uuid', 'relation-token': 'relation_token', 'remote-endpoint': 'remote_endpoint', 'remote-space': 'remote_space', 'source-model-tag': 'source_model_tag'}
7443     def __init__(self, application_token=None, local_endpoint_name=None, macaroons=None, offer_uuid=None, relation_token=None, remote_endpoint=None, remote_space=None, source_model_tag=None, **unknown_fields):
7444         '''
7445         application_token : str
7446         local_endpoint_name : str
7447         macaroons : typing.Sequence[~Macaroon]
7448         offer_uuid : str
7449         relation_token : str
7450         remote_endpoint : RemoteEndpoint
7451         remote_space : RemoteSpace
7452         source_model_tag : str
7453         '''
7454         self.application_token = application_token
7455         self.local_endpoint_name = local_endpoint_name
7456         self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
7457         self.offer_uuid = offer_uuid
7458         self.relation_token = relation_token
7459         self.remote_endpoint = RemoteEndpoint.from_json(remote_endpoint) if remote_endpoint else None
7460         self.remote_space = RemoteSpace.from_json(remote_space) if remote_space else None
7461         self.source_model_tag = source_model_tag
7462
7463
7464
7465 class RegisterRemoteRelationArgs(Type):
7466     _toSchema = {'relations': 'relations'}
7467     _toPy = {'relations': 'relations'}
7468     def __init__(self, relations=None, **unknown_fields):
7469         '''
7470         relations : typing.Sequence[~RegisterRemoteRelationArg]
7471         '''
7472         self.relations = [RegisterRemoteRelationArg.from_json(o) for o in relations or []]
7473
7474
7475
7476 class RegisterRemoteRelationResult(Type):
7477     _toSchema = {'error': 'error', 'result': 'result'}
7478     _toPy = {'error': 'error', 'result': 'result'}
7479     def __init__(self, error=None, result=None, **unknown_fields):
7480         '''
7481         error : Error
7482         result : RemoteRelationDetails
7483         '''
7484         self.error = Error.from_json(error) if error else None
7485         self.result = RemoteRelationDetails.from_json(result) if result else None
7486
7487
7488
7489 class RegisterRemoteRelationResults(Type):
7490     _toSchema = {'results': 'results'}
7491     _toPy = {'results': 'results'}
7492     def __init__(self, results=None, **unknown_fields):
7493         '''
7494         results : typing.Sequence[~RegisterRemoteRelationResult]
7495         '''
7496         self.results = [RegisterRemoteRelationResult.from_json(o) for o in results or []]
7497
7498
7499
7500 class RelationChange(Type):
7501     _toSchema = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id_': 'id', 'life': 'life'}
7502     _toPy = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id': 'id_', 'life': 'life'}
7503     def __init__(self, changedunits=None, departedunits=None, id_=None, life=None, **unknown_fields):
7504         '''
7505         changedunits : typing.Mapping[str, ~RelationUnitChange]
7506         departedunits : typing.Sequence[str]
7507         id_ : int
7508         life : str
7509         '''
7510         self.changedunits = changedunits
7511         self.departedunits = departedunits
7512         self.id_ = id_
7513         self.life = life
7514
7515
7516
7517 class RelationIds(Type):
7518     _toSchema = {'relation_ids': 'relation-ids'}
7519     _toPy = {'relation-ids': 'relation_ids'}
7520     def __init__(self, relation_ids=None, **unknown_fields):
7521         '''
7522         relation_ids : typing.Sequence[int]
7523         '''
7524         self.relation_ids = relation_ids
7525
7526
7527
7528 class RelationLifeSuspendedStatusChange(Type):
7529     _toSchema = {'key': 'key', 'life': 'life', 'suspended': 'suspended', 'suspended_reason': 'suspended-reason'}
7530     _toPy = {'key': 'key', 'life': 'life', 'suspended': 'suspended', 'suspended-reason': 'suspended_reason'}
7531     def __init__(self, key=None, life=None, suspended=None, suspended_reason=None, **unknown_fields):
7532         '''
7533         key : str
7534         life : str
7535         suspended : bool
7536         suspended_reason : str
7537         '''
7538         self.key = key
7539         self.life = life
7540         self.suspended = suspended
7541         self.suspended_reason = suspended_reason
7542
7543
7544
7545 class RelationLifeSuspendedStatusWatchResult(Type):
7546     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
7547     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
7548     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
7549         '''
7550         changes : typing.Sequence[~RelationLifeSuspendedStatusChange]
7551         error : Error
7552         watcher_id : str
7553         '''
7554         self.changes = [RelationLifeSuspendedStatusChange.from_json(o) for o in changes or []]
7555         self.error = Error.from_json(error) if error else None
7556         self.watcher_id = watcher_id
7557
7558
7559
7560 class RelationResult(Type):
7561     _toSchema = {'endpoint': 'endpoint', 'error': 'error', 'id_': 'id', 'key': 'key', 'life': 'life'}
7562     _toPy = {'endpoint': 'endpoint', 'error': 'error', 'id': 'id_', 'key': 'key', 'life': 'life'}
7563     def __init__(self, endpoint=None, error=None, id_=None, key=None, life=None, **unknown_fields):
7564         '''
7565         endpoint : Endpoint
7566         error : Error
7567         id_ : int
7568         key : str
7569         life : str
7570         '''
7571         self.endpoint = Endpoint.from_json(endpoint) if endpoint else None
7572         self.error = Error.from_json(error) if error else None
7573         self.id_ = id_
7574         self.key = key
7575         self.life = life
7576
7577
7578
7579 class RelationResults(Type):
7580     _toSchema = {'results': 'results'}
7581     _toPy = {'results': 'results'}
7582     def __init__(self, results=None, **unknown_fields):
7583         '''
7584         results : typing.Sequence[~RelationResult]
7585         '''
7586         self.results = [RelationResult.from_json(o) for o in results or []]
7587
7588
7589
7590 class RelationStatus(Type):
7591     _toSchema = {'endpoints': 'endpoints', 'id_': 'id', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
7592     _toPy = {'endpoints': 'endpoints', 'id': 'id_', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
7593     def __init__(self, endpoints=None, id_=None, interface=None, key=None, scope=None, **unknown_fields):
7594         '''
7595         endpoints : typing.Sequence[~EndpointStatus]
7596         id_ : int
7597         interface : str
7598         key : str
7599         scope : str
7600         '''
7601         self.endpoints = [EndpointStatus.from_json(o) for o in endpoints or []]
7602         self.id_ = id_
7603         self.interface = interface
7604         self.key = key
7605         self.scope = scope
7606
7607
7608
7609 class RelationStatusArg(Type):
7610     _toSchema = {'message': 'message', 'relation_id': 'relation-id', 'status': 'status', 'unit_tag': 'unit-tag'}
7611     _toPy = {'message': 'message', 'relation-id': 'relation_id', 'status': 'status', 'unit-tag': 'unit_tag'}
7612     def __init__(self, message=None, relation_id=None, status=None, unit_tag=None, **unknown_fields):
7613         '''
7614         message : str
7615         relation_id : int
7616         status : str
7617         unit_tag : str
7618         '''
7619         self.message = message
7620         self.relation_id = relation_id
7621         self.status = status
7622         self.unit_tag = unit_tag
7623
7624
7625
7626 class RelationStatusArgs(Type):
7627     _toSchema = {'args': 'args'}
7628     _toPy = {'args': 'args'}
7629     def __init__(self, args=None, **unknown_fields):
7630         '''
7631         args : typing.Sequence[~RelationStatusArg]
7632         '''
7633         self.args = [RelationStatusArg.from_json(o) for o in args or []]
7634
7635
7636
7637 class RelationStatusWatchResults(Type):
7638     _toSchema = {'results': 'results'}
7639     _toPy = {'results': 'results'}
7640     def __init__(self, results=None, **unknown_fields):
7641         '''
7642         results : typing.Sequence[~RelationLifeSuspendedStatusWatchResult]
7643         '''
7644         self.results = [RelationLifeSuspendedStatusWatchResult.from_json(o) for o in results or []]
7645
7646
7647
7648 class RelationSuspendedArg(Type):
7649     _toSchema = {'message': 'message', 'relation_id': 'relation-id', 'suspended': 'suspended'}
7650     _toPy = {'message': 'message', 'relation-id': 'relation_id', 'suspended': 'suspended'}
7651     def __init__(self, message=None, relation_id=None, suspended=None, **unknown_fields):
7652         '''
7653         message : str
7654         relation_id : int
7655         suspended : bool
7656         '''
7657         self.message = message
7658         self.relation_id = relation_id
7659         self.suspended = suspended
7660
7661
7662
7663 class RelationSuspendedArgs(Type):
7664     _toSchema = {'args': 'args'}
7665     _toPy = {'args': 'args'}
7666     def __init__(self, args=None, **unknown_fields):
7667         '''
7668         args : typing.Sequence[~RelationSuspendedArg]
7669         '''
7670         self.args = [RelationSuspendedArg.from_json(o) for o in args or []]
7671
7672
7673
7674 class RelationUnit(Type):
7675     _toSchema = {'relation': 'relation', 'unit': 'unit'}
7676     _toPy = {'relation': 'relation', 'unit': 'unit'}
7677     def __init__(self, relation=None, unit=None, **unknown_fields):
7678         '''
7679         relation : str
7680         unit : str
7681         '''
7682         self.relation = relation
7683         self.unit = unit
7684
7685
7686
7687 class RelationUnitChange(Type):
7688     _toSchema = {'settings': 'settings'}
7689     _toPy = {'settings': 'settings'}
7690     def __init__(self, settings=None, **unknown_fields):
7691         '''
7692         settings : typing.Mapping[str, typing.Any]
7693         '''
7694         self.settings = settings
7695
7696
7697
7698 class RelationUnitPair(Type):
7699     _toSchema = {'local_unit': 'local-unit', 'relation': 'relation', 'remote_unit': 'remote-unit'}
7700     _toPy = {'local-unit': 'local_unit', 'relation': 'relation', 'remote-unit': 'remote_unit'}
7701     def __init__(self, local_unit=None, relation=None, remote_unit=None, **unknown_fields):
7702         '''
7703         local_unit : str
7704         relation : str
7705         remote_unit : str
7706         '''
7707         self.local_unit = local_unit
7708         self.relation = relation
7709         self.remote_unit = remote_unit
7710
7711
7712
7713 class RelationUnitPairs(Type):
7714     _toSchema = {'relation_unit_pairs': 'relation-unit-pairs'}
7715     _toPy = {'relation-unit-pairs': 'relation_unit_pairs'}
7716     def __init__(self, relation_unit_pairs=None, **unknown_fields):
7717         '''
7718         relation_unit_pairs : typing.Sequence[~RelationUnitPair]
7719         '''
7720         self.relation_unit_pairs = [RelationUnitPair.from_json(o) for o in relation_unit_pairs or []]
7721
7722
7723
7724 class RelationUnitSettings(Type):
7725     _toSchema = {'relation': 'relation', 'settings': 'settings', 'unit': 'unit'}
7726     _toPy = {'relation': 'relation', 'settings': 'settings', 'unit': 'unit'}
7727     def __init__(self, relation=None, settings=None, unit=None, **unknown_fields):
7728         '''
7729         relation : str
7730         settings : typing.Mapping[str, str]
7731         unit : str
7732         '''
7733         self.relation = relation
7734         self.settings = settings
7735         self.unit = unit
7736
7737
7738
7739 class RelationUnitStatus(Type):
7740     _toSchema = {'in_scope': 'in-scope', 'relation_tag': 'relation-tag', 'suspended': 'suspended'}
7741     _toPy = {'in-scope': 'in_scope', 'relation-tag': 'relation_tag', 'suspended': 'suspended'}
7742     def __init__(self, in_scope=None, relation_tag=None, suspended=None, **unknown_fields):
7743         '''
7744         in_scope : bool
7745         relation_tag : str
7746         suspended : bool
7747         '''
7748         self.in_scope = in_scope
7749         self.relation_tag = relation_tag
7750         self.suspended = suspended
7751
7752
7753
7754 class RelationUnitStatusResult(Type):
7755     _toSchema = {'error': 'error', 'results': 'results'}
7756     _toPy = {'error': 'error', 'results': 'results'}
7757     def __init__(self, error=None, results=None, **unknown_fields):
7758         '''
7759         error : Error
7760         results : typing.Sequence[~RelationUnitStatus]
7761         '''
7762         self.error = Error.from_json(error) if error else None
7763         self.results = [RelationUnitStatus.from_json(o) for o in results or []]
7764
7765
7766
7767 class RelationUnitStatusResults(Type):
7768     _toSchema = {'results': 'results'}
7769     _toPy = {'results': 'results'}
7770     def __init__(self, results=None, **unknown_fields):
7771         '''
7772         results : typing.Sequence[~RelationUnitStatusResult]
7773         '''
7774         self.results = [RelationUnitStatusResult.from_json(o) for o in results or []]
7775
7776
7777
7778 class RelationUnits(Type):
7779     _toSchema = {'relation_units': 'relation-units'}
7780     _toPy = {'relation-units': 'relation_units'}
7781     def __init__(self, relation_units=None, **unknown_fields):
7782         '''
7783         relation_units : typing.Sequence[~RelationUnit]
7784         '''
7785         self.relation_units = [RelationUnit.from_json(o) for o in relation_units or []]
7786
7787
7788
7789 class RelationUnitsChange(Type):
7790     _toSchema = {'changed': 'changed', 'departed': 'departed'}
7791     _toPy = {'changed': 'changed', 'departed': 'departed'}
7792     def __init__(self, changed=None, departed=None, **unknown_fields):
7793         '''
7794         changed : typing.Mapping[str, ~UnitSettings]
7795         departed : typing.Sequence[str]
7796         '''
7797         self.changed = changed
7798         self.departed = departed
7799
7800
7801
7802 class RelationUnitsSettings(Type):
7803     _toSchema = {'relation_units': 'relation-units'}
7804     _toPy = {'relation-units': 'relation_units'}
7805     def __init__(self, relation_units=None, **unknown_fields):
7806         '''
7807         relation_units : typing.Sequence[~RelationUnitSettings]
7808         '''
7809         self.relation_units = [RelationUnitSettings.from_json(o) for o in relation_units or []]
7810
7811
7812
7813 class RelationUnitsWatchResult(Type):
7814     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
7815     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
7816     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
7817         '''
7818         changes : RelationUnitsChange
7819         error : Error
7820         watcher_id : str
7821         '''
7822         self.changes = RelationUnitsChange.from_json(changes) if changes else None
7823         self.error = Error.from_json(error) if error else None
7824         self.watcher_id = watcher_id
7825
7826
7827
7828 class RelationUnitsWatchResults(Type):
7829     _toSchema = {'results': 'results'}
7830     _toPy = {'results': 'results'}
7831     def __init__(self, results=None, **unknown_fields):
7832         '''
7833         results : typing.Sequence[~RelationUnitsWatchResult]
7834         '''
7835         self.results = [RelationUnitsWatchResult.from_json(o) for o in results or []]
7836
7837
7838
7839 class RemoteApplication(Type):
7840     _toSchema = {'is_consumer_proxy': 'is-consumer-proxy', 'life': 'life', 'macaroon': 'macaroon', 'model_uuid': 'model-uuid', 'name': 'name', 'offer_uuid': 'offer-uuid', 'status': 'status'}
7841     _toPy = {'is-consumer-proxy': 'is_consumer_proxy', 'life': 'life', 'macaroon': 'macaroon', 'model-uuid': 'model_uuid', 'name': 'name', 'offer-uuid': 'offer_uuid', 'status': 'status'}
7842     def __init__(self, is_consumer_proxy=None, life=None, macaroon=None, model_uuid=None, name=None, offer_uuid=None, status=None, **unknown_fields):
7843         '''
7844         is_consumer_proxy : bool
7845         life : str
7846         macaroon : Macaroon
7847         model_uuid : str
7848         name : str
7849         offer_uuid : str
7850         status : str
7851         '''
7852         self.is_consumer_proxy = is_consumer_proxy
7853         self.life = life
7854         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
7855         self.model_uuid = model_uuid
7856         self.name = name
7857         self.offer_uuid = offer_uuid
7858         self.status = status
7859
7860
7861
7862 class RemoteApplicationChange(Type):
7863     _toSchema = {'application_tag': 'application-tag', 'life': 'life', 'relations': 'relations'}
7864     _toPy = {'application-tag': 'application_tag', 'life': 'life', 'relations': 'relations'}
7865     def __init__(self, application_tag=None, life=None, relations=None, **unknown_fields):
7866         '''
7867         application_tag : str
7868         life : str
7869         relations : RemoteRelationsChange
7870         '''
7871         self.application_tag = application_tag
7872         self.life = life
7873         self.relations = RemoteRelationsChange.from_json(relations) if relations else None
7874
7875
7876
7877 class RemoteApplicationInfo(Type):
7878     _toSchema = {'application_url': 'application-url', 'description': 'description', 'endpoints': 'endpoints', 'icon_url_path': 'icon-url-path', 'model_tag': 'model-tag', 'name': 'name', 'source_model_label': 'source-model-label'}
7879     _toPy = {'application-url': 'application_url', 'description': 'description', 'endpoints': 'endpoints', 'icon-url-path': 'icon_url_path', 'model-tag': 'model_tag', 'name': 'name', 'source-model-label': 'source_model_label'}
7880     def __init__(self, application_url=None, description=None, endpoints=None, icon_url_path=None, model_tag=None, name=None, source_model_label=None, **unknown_fields):
7881         '''
7882         application_url : str
7883         description : str
7884         endpoints : typing.Sequence[~RemoteEndpoint]
7885         icon_url_path : str
7886         model_tag : str
7887         name : str
7888         source_model_label : str
7889         '''
7890         self.application_url = application_url
7891         self.description = description
7892         self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
7893         self.icon_url_path = icon_url_path
7894         self.model_tag = model_tag
7895         self.name = name
7896         self.source_model_label = source_model_label
7897
7898
7899
7900 class RemoteApplicationInfoResult(Type):
7901     _toSchema = {'error': 'error', 'result': 'result'}
7902     _toPy = {'error': 'error', 'result': 'result'}
7903     def __init__(self, error=None, result=None, **unknown_fields):
7904         '''
7905         error : Error
7906         result : RemoteApplicationInfo
7907         '''
7908         self.error = Error.from_json(error) if error else None
7909         self.result = RemoteApplicationInfo.from_json(result) if result else None
7910
7911
7912
7913 class RemoteApplicationInfoResults(Type):
7914     _toSchema = {'results': 'results'}
7915     _toPy = {'results': 'results'}
7916     def __init__(self, results=None, **unknown_fields):
7917         '''
7918         results : typing.Sequence[~RemoteApplicationInfoResult]
7919         '''
7920         self.results = [RemoteApplicationInfoResult.from_json(o) for o in results or []]
7921
7922
7923
7924 class RemoteApplicationResult(Type):
7925     _toSchema = {'error': 'error', 'result': 'result'}
7926     _toPy = {'error': 'error', 'result': 'result'}
7927     def __init__(self, error=None, result=None, **unknown_fields):
7928         '''
7929         error : Error
7930         result : RemoteApplication
7931         '''
7932         self.error = Error.from_json(error) if error else None
7933         self.result = RemoteApplication.from_json(result) if result else None
7934
7935
7936
7937 class RemoteApplicationResults(Type):
7938     _toSchema = {'results': 'results'}
7939     _toPy = {'results': 'results'}
7940     def __init__(self, results=None, **unknown_fields):
7941         '''
7942         results : typing.Sequence[~RemoteApplicationResult]
7943         '''
7944         self.results = [RemoteApplicationResult.from_json(o) for o in results or []]
7945
7946
7947
7948 class RemoteApplicationStatus(Type):
7949     _toSchema = {'application_name': 'application-name', 'application_url': 'application-url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
7950     _toPy = {'application-name': 'application_name', 'application-url': 'application_url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
7951     def __init__(self, application_name=None, application_url=None, endpoints=None, err=None, life=None, relations=None, status=None, **unknown_fields):
7952         '''
7953         application_name : str
7954         application_url : str
7955         endpoints : typing.Sequence[~RemoteEndpoint]
7956         err : typing.Mapping[str, typing.Any]
7957         life : str
7958         relations : typing.Sequence[str]
7959         status : DetailedStatus
7960         '''
7961         self.application_name = application_name
7962         self.application_url = application_url
7963         self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
7964         self.err = err
7965         self.life = life
7966         self.relations = relations
7967         self.status = DetailedStatus.from_json(status) if status else None
7968
7969
7970
7971 class RemoteApplicationWatchResult(Type):
7972     _toSchema = {'change': 'change', 'error': 'error', 'id_': 'id'}
7973     _toPy = {'change': 'change', 'error': 'error', 'id': 'id_'}
7974     def __init__(self, change=None, error=None, id_=None, **unknown_fields):
7975         '''
7976         change : RemoteApplicationChange
7977         error : Error
7978         id_ : str
7979         '''
7980         self.change = RemoteApplicationChange.from_json(change) if change else None
7981         self.error = Error.from_json(error) if error else None
7982         self.id_ = id_
7983
7984
7985
7986 class RemoteEndpoint(Type):
7987     _toSchema = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'role': 'role', 'scope': 'scope'}
7988     _toPy = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'role': 'role', 'scope': 'scope'}
7989     def __init__(self, interface=None, limit=None, name=None, role=None, scope=None, **unknown_fields):
7990         '''
7991         interface : str
7992         limit : int
7993         name : str
7994         role : str
7995         scope : str
7996         '''
7997         self.interface = interface
7998         self.limit = limit
7999         self.name = name
8000         self.role = role
8001         self.scope = scope
8002
8003
8004
8005 class RemoteEntityArg(Type):
8006     _toSchema = {'macaroons': 'macaroons', 'relation_token': 'relation-token'}
8007     _toPy = {'macaroons': 'macaroons', 'relation-token': 'relation_token'}
8008     def __init__(self, macaroons=None, relation_token=None, **unknown_fields):
8009         '''
8010         macaroons : typing.Sequence[~Macaroon]
8011         relation_token : str
8012         '''
8013         self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
8014         self.relation_token = relation_token
8015
8016
8017
8018 class RemoteEntityArgs(Type):
8019     _toSchema = {'args': 'args'}
8020     _toPy = {'args': 'args'}
8021     def __init__(self, args=None, **unknown_fields):
8022         '''
8023         args : typing.Sequence[~RemoteEntityArg]
8024         '''
8025         self.args = [RemoteEntityArg.from_json(o) for o in args or []]
8026
8027
8028
8029 class RemoteEntityId(Type):
8030     _toSchema = {'model_uuid': 'model-uuid', 'token': 'token'}
8031     _toPy = {'model-uuid': 'model_uuid', 'token': 'token'}
8032     def __init__(self, model_uuid=None, token=None, **unknown_fields):
8033         '''
8034         model_uuid : str
8035         token : str
8036         '''
8037         self.model_uuid = model_uuid
8038         self.token = token
8039
8040
8041
8042 class RemoteEntityTokenArg(Type):
8043     _toSchema = {'tag': 'tag', 'token': 'token'}
8044     _toPy = {'tag': 'tag', 'token': 'token'}
8045     def __init__(self, tag=None, token=None, **unknown_fields):
8046         '''
8047         tag : str
8048         token : str
8049         '''
8050         self.tag = tag
8051         self.token = token
8052
8053
8054
8055 class RemoteEntityTokenArgs(Type):
8056     _toSchema = {'args': 'Args'}
8057     _toPy = {'Args': 'args'}
8058     def __init__(self, args=None, **unknown_fields):
8059         '''
8060         args : typing.Sequence[~RemoteEntityTokenArg]
8061         '''
8062         self.args = [RemoteEntityTokenArg.from_json(o) for o in args or []]
8063
8064
8065
8066 class RemoteRelation(Type):
8067     _toSchema = {'application_name': 'application-name', 'endpoint': 'endpoint', 'id_': 'id', 'key': 'key', 'life': 'life', 'remote_application_name': 'remote-application-name', 'remote_endpoint_name': 'remote-endpoint-name', 'source_model_uuid': 'source-model-uuid', 'suspended': 'suspended'}
8068     _toPy = {'application-name': 'application_name', 'endpoint': 'endpoint', 'id': 'id_', 'key': 'key', 'life': 'life', 'remote-application-name': 'remote_application_name', 'remote-endpoint-name': 'remote_endpoint_name', 'source-model-uuid': 'source_model_uuid', 'suspended': 'suspended'}
8069     def __init__(self, application_name=None, endpoint=None, id_=None, key=None, life=None, remote_application_name=None, remote_endpoint_name=None, source_model_uuid=None, suspended=None, **unknown_fields):
8070         '''
8071         application_name : str
8072         endpoint : RemoteEndpoint
8073         id_ : int
8074         key : str
8075         life : str
8076         remote_application_name : str
8077         remote_endpoint_name : str
8078         source_model_uuid : str
8079         suspended : bool
8080         '''
8081         self.application_name = application_name
8082         self.endpoint = RemoteEndpoint.from_json(endpoint) if endpoint else None
8083         self.id_ = id_
8084         self.key = key
8085         self.life = life
8086         self.remote_application_name = remote_application_name
8087         self.remote_endpoint_name = remote_endpoint_name
8088         self.source_model_uuid = source_model_uuid
8089         self.suspended = suspended
8090
8091
8092
8093 class RemoteRelationChange(Type):
8094     _toSchema = {'changed_units': 'changed-units', 'departed_units': 'departed-units', 'id_': 'id', 'life': 'life'}
8095     _toPy = {'changed-units': 'changed_units', 'departed-units': 'departed_units', 'id': 'id_', 'life': 'life'}
8096     def __init__(self, changed_units=None, departed_units=None, id_=None, life=None, **unknown_fields):
8097         '''
8098         changed_units : typing.Mapping[str, ~RemoteRelationUnitChange]
8099         departed_units : typing.Sequence[str]
8100         id_ : int
8101         life : str
8102         '''
8103         self.changed_units = changed_units
8104         self.departed_units = departed_units
8105         self.id_ = id_
8106         self.life = life
8107
8108
8109
8110 class RemoteRelationChangeEvent(Type):
8111     _toSchema = {'application_token': 'application-token', 'changed_units': 'changed-units', 'departed_units': 'departed-units', 'force_cleanup': 'force-cleanup', 'life': 'life', 'macaroons': 'macaroons', 'relation_token': 'relation-token', 'suspended': 'suspended', 'suspended_reason': 'suspended-reason'}
8112     _toPy = {'application-token': 'application_token', 'changed-units': 'changed_units', 'departed-units': 'departed_units', 'force-cleanup': 'force_cleanup', 'life': 'life', 'macaroons': 'macaroons', 'relation-token': 'relation_token', 'suspended': 'suspended', 'suspended-reason': 'suspended_reason'}
8113     def __init__(self, application_token=None, changed_units=None, departed_units=None, force_cleanup=None, life=None, macaroons=None, relation_token=None, suspended=None, suspended_reason=None, **unknown_fields):
8114         '''
8115         application_token : str
8116         changed_units : typing.Sequence[~RemoteRelationUnitChange]
8117         departed_units : typing.Sequence[int]
8118         force_cleanup : bool
8119         life : str
8120         macaroons : typing.Sequence[~Macaroon]
8121         relation_token : str
8122         suspended : bool
8123         suspended_reason : str
8124         '''
8125         self.application_token = application_token
8126         self.changed_units = [RemoteRelationUnitChange.from_json(o) for o in changed_units or []]
8127         self.departed_units = departed_units
8128         self.force_cleanup = force_cleanup
8129         self.life = life
8130         self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
8131         self.relation_token = relation_token
8132         self.suspended = suspended
8133         self.suspended_reason = suspended_reason
8134
8135
8136
8137 class RemoteRelationDetails(Type):
8138     _toSchema = {'macaroon': 'macaroon', 'relation_token': 'relation-token'}
8139     _toPy = {'macaroon': 'macaroon', 'relation-token': 'relation_token'}
8140     def __init__(self, macaroon=None, relation_token=None, **unknown_fields):
8141         '''
8142         macaroon : Macaroon
8143         relation_token : str
8144         '''
8145         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
8146         self.relation_token = relation_token
8147
8148
8149
8150 class RemoteRelationResult(Type):
8151     _toSchema = {'error': 'error', 'result': 'result'}
8152     _toPy = {'error': 'error', 'result': 'result'}
8153     def __init__(self, error=None, result=None, **unknown_fields):
8154         '''
8155         error : Error
8156         result : RemoteRelation
8157         '''
8158         self.error = Error.from_json(error) if error else None
8159         self.result = RemoteRelation.from_json(result) if result else None
8160
8161
8162
8163 class RemoteRelationResults(Type):
8164     _toSchema = {'results': 'results'}
8165     _toPy = {'results': 'results'}
8166     def __init__(self, results=None, **unknown_fields):
8167         '''
8168         results : typing.Sequence[~RemoteRelationResult]
8169         '''
8170         self.results = [RemoteRelationResult.from_json(o) for o in results or []]
8171
8172
8173
8174 class RemoteRelationUnit(Type):
8175     _toSchema = {'macaroons': 'macaroons', 'relation_token': 'relation-token', 'unit': 'unit'}
8176     _toPy = {'macaroons': 'macaroons', 'relation-token': 'relation_token', 'unit': 'unit'}
8177     def __init__(self, macaroons=None, relation_token=None, unit=None, **unknown_fields):
8178         '''
8179         macaroons : typing.Sequence[~Macaroon]
8180         relation_token : str
8181         unit : str
8182         '''
8183         self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
8184         self.relation_token = relation_token
8185         self.unit = unit
8186
8187
8188
8189 class RemoteRelationUnitChange(Type):
8190     _toSchema = {'settings': 'settings', 'unit_id': 'unit-id'}
8191     _toPy = {'settings': 'settings', 'unit-id': 'unit_id'}
8192     def __init__(self, settings=None, unit_id=None, **unknown_fields):
8193         '''
8194         settings : typing.Mapping[str, typing.Any]
8195         unit_id : RemoteEntityId
8196         '''
8197         self.settings = settings
8198         self.unit_id = RemoteEntityId.from_json(unit_id) if unit_id else None
8199
8200
8201
8202 class RemoteRelationUnits(Type):
8203     _toSchema = {'relation_units': 'relation-units'}
8204     _toPy = {'relation-units': 'relation_units'}
8205     def __init__(self, relation_units=None, **unknown_fields):
8206         '''
8207         relation_units : typing.Sequence[~RemoteRelationUnit]
8208         '''
8209         self.relation_units = [RemoteRelationUnit.from_json(o) for o in relation_units or []]
8210
8211
8212
8213 class RemoteRelationsChange(Type):
8214     _toSchema = {'changed': 'changed', 'initial': 'initial', 'removed': 'removed'}
8215     _toPy = {'changed': 'changed', 'initial': 'initial', 'removed': 'removed'}
8216     def __init__(self, changed=None, initial=None, removed=None, **unknown_fields):
8217         '''
8218         changed : typing.Sequence[~RemoteRelationChange]
8219         initial : bool
8220         removed : typing.Sequence[int]
8221         '''
8222         self.changed = [RemoteRelationChange.from_json(o) for o in changed or []]
8223         self.initial = initial
8224         self.removed = removed
8225
8226
8227
8228 class RemoteRelationsChanges(Type):
8229     _toSchema = {'changes': 'changes'}
8230     _toPy = {'changes': 'changes'}
8231     def __init__(self, changes=None, **unknown_fields):
8232         '''
8233         changes : typing.Sequence[~RemoteRelationChangeEvent]
8234         '''
8235         self.changes = [RemoteRelationChangeEvent.from_json(o) for o in changes or []]
8236
8237
8238
8239 class RemoteRelationsWatchResult(Type):
8240     _toSchema = {'change': 'change', 'error': 'error', 'remoterelationswatcherid': 'RemoteRelationsWatcherId'}
8241     _toPy = {'RemoteRelationsWatcherId': 'remoterelationswatcherid', 'change': 'change', 'error': 'error'}
8242     def __init__(self, remoterelationswatcherid=None, change=None, error=None, **unknown_fields):
8243         '''
8244         remoterelationswatcherid : str
8245         change : RemoteRelationsChange
8246         error : Error
8247         '''
8248         self.remoterelationswatcherid = remoterelationswatcherid
8249         self.change = RemoteRelationsChange.from_json(change) if change else None
8250         self.error = Error.from_json(error) if error else None
8251
8252
8253
8254 class RemoteSpace(Type):
8255     _toSchema = {'cloud_type': 'cloud-type', 'name': 'name', 'provider_attributes': 'provider-attributes', 'provider_id': 'provider-id', 'subnets': 'subnets'}
8256     _toPy = {'cloud-type': 'cloud_type', 'name': 'name', 'provider-attributes': 'provider_attributes', 'provider-id': 'provider_id', 'subnets': 'subnets'}
8257     def __init__(self, cloud_type=None, name=None, provider_attributes=None, provider_id=None, subnets=None, **unknown_fields):
8258         '''
8259         cloud_type : str
8260         name : str
8261         provider_attributes : typing.Mapping[str, typing.Any]
8262         provider_id : str
8263         subnets : typing.Sequence[~Subnet]
8264         '''
8265         self.cloud_type = cloud_type
8266         self.name = name
8267         self.provider_attributes = provider_attributes
8268         self.provider_id = provider_id
8269         self.subnets = [Subnet.from_json(o) for o in subnets or []]
8270
8271
8272
8273 class RemoveBlocksArgs(Type):
8274     _toSchema = {'all_': 'all'}
8275     _toPy = {'all': 'all_'}
8276     def __init__(self, all_=None, **unknown_fields):
8277         '''
8278         all_ : bool
8279         '''
8280         self.all_ = all_
8281
8282
8283
8284 class RemoveFilesystemParams(Type):
8285     _toSchema = {'destroy': 'destroy', 'filesystem_id': 'filesystem-id', 'provider': 'provider'}
8286     _toPy = {'destroy': 'destroy', 'filesystem-id': 'filesystem_id', 'provider': 'provider'}
8287     def __init__(self, destroy=None, filesystem_id=None, provider=None, **unknown_fields):
8288         '''
8289         destroy : bool
8290         filesystem_id : str
8291         provider : str
8292         '''
8293         self.destroy = destroy
8294         self.filesystem_id = filesystem_id
8295         self.provider = provider
8296
8297
8298
8299 class RemoveFilesystemParamsResult(Type):
8300     _toSchema = {'error': 'error', 'result': 'result'}
8301     _toPy = {'error': 'error', 'result': 'result'}
8302     def __init__(self, error=None, result=None, **unknown_fields):
8303         '''
8304         error : Error
8305         result : RemoveFilesystemParams
8306         '''
8307         self.error = Error.from_json(error) if error else None
8308         self.result = RemoveFilesystemParams.from_json(result) if result else None
8309
8310
8311
8312 class RemoveFilesystemParamsResults(Type):
8313     _toSchema = {'results': 'results'}
8314     _toPy = {'results': 'results'}
8315     def __init__(self, results=None, **unknown_fields):
8316         '''
8317         results : typing.Sequence[~RemoveFilesystemParamsResult]
8318         '''
8319         self.results = [RemoveFilesystemParamsResult.from_json(o) for o in results or []]
8320
8321
8322
8323 class RemoveStorage(Type):
8324     _toSchema = {'storage': 'storage'}
8325     _toPy = {'storage': 'storage'}
8326     def __init__(self, storage=None, **unknown_fields):
8327         '''
8328         storage : typing.Sequence[~RemoveStorageInstance]
8329         '''
8330         self.storage = [RemoveStorageInstance.from_json(o) for o in storage or []]
8331
8332
8333
8334 class RemoveStorageInstance(Type):
8335     _toSchema = {'destroy_attachments': 'destroy-attachments', 'destroy_storage': 'destroy-storage', 'tag': 'tag'}
8336     _toPy = {'destroy-attachments': 'destroy_attachments', 'destroy-storage': 'destroy_storage', 'tag': 'tag'}
8337     def __init__(self, destroy_attachments=None, destroy_storage=None, tag=None, **unknown_fields):
8338         '''
8339         destroy_attachments : bool
8340         destroy_storage : bool
8341         tag : str
8342         '''
8343         self.destroy_attachments = destroy_attachments
8344         self.destroy_storage = destroy_storage
8345         self.tag = tag
8346
8347
8348
8349 class RemoveVolumeParams(Type):
8350     _toSchema = {'destroy': 'destroy', 'provider': 'provider', 'volume_id': 'volume-id'}
8351     _toPy = {'destroy': 'destroy', 'provider': 'provider', 'volume-id': 'volume_id'}
8352     def __init__(self, destroy=None, provider=None, volume_id=None, **unknown_fields):
8353         '''
8354         destroy : bool
8355         provider : str
8356         volume_id : str
8357         '''
8358         self.destroy = destroy
8359         self.provider = provider
8360         self.volume_id = volume_id
8361
8362
8363
8364 class RemoveVolumeParamsResult(Type):
8365     _toSchema = {'error': 'error', 'result': 'result'}
8366     _toPy = {'error': 'error', 'result': 'result'}
8367     def __init__(self, error=None, result=None, **unknown_fields):
8368         '''
8369         error : Error
8370         result : RemoveVolumeParams
8371         '''
8372         self.error = Error.from_json(error) if error else None
8373         self.result = RemoveVolumeParams.from_json(result) if result else None
8374
8375
8376
8377 class RemoveVolumeParamsResults(Type):
8378     _toSchema = {'results': 'results'}
8379     _toPy = {'results': 'results'}
8380     def __init__(self, results=None, **unknown_fields):
8381         '''
8382         results : typing.Sequence[~RemoveVolumeParamsResult]
8383         '''
8384         self.results = [RemoveVolumeParamsResult.from_json(o) for o in results or []]
8385
8386
8387
8388 class ResolveCharmResult(Type):
8389     _toSchema = {'error': 'error', 'url': 'url'}
8390     _toPy = {'error': 'error', 'url': 'url'}
8391     def __init__(self, error=None, url=None, **unknown_fields):
8392         '''
8393         error : str
8394         url : str
8395         '''
8396         self.error = error
8397         self.url = url
8398
8399
8400
8401 class ResolveCharmResults(Type):
8402     _toSchema = {'urls': 'urls'}
8403     _toPy = {'urls': 'urls'}
8404     def __init__(self, urls=None, **unknown_fields):
8405         '''
8406         urls : typing.Sequence[~ResolveCharmResult]
8407         '''
8408         self.urls = [ResolveCharmResult.from_json(o) for o in urls or []]
8409
8410
8411
8412 class ResolveCharms(Type):
8413     _toSchema = {'references': 'references'}
8414     _toPy = {'references': 'references'}
8415     def __init__(self, references=None, **unknown_fields):
8416         '''
8417         references : typing.Sequence[str]
8418         '''
8419         self.references = references
8420
8421
8422
8423 class Resolved(Type):
8424     _toSchema = {'retry': 'retry', 'unit_name': 'unit-name'}
8425     _toPy = {'retry': 'retry', 'unit-name': 'unit_name'}
8426     def __init__(self, retry=None, unit_name=None, **unknown_fields):
8427         '''
8428         retry : bool
8429         unit_name : str
8430         '''
8431         self.retry = retry
8432         self.unit_name = unit_name
8433
8434
8435
8436 class ResolvedModeResult(Type):
8437     _toSchema = {'error': 'error', 'mode': 'mode'}
8438     _toPy = {'error': 'error', 'mode': 'mode'}
8439     def __init__(self, error=None, mode=None, **unknown_fields):
8440         '''
8441         error : Error
8442         mode : str
8443         '''
8444         self.error = Error.from_json(error) if error else None
8445         self.mode = mode
8446
8447
8448
8449 class ResolvedModeResults(Type):
8450     _toSchema = {'results': 'results'}
8451     _toPy = {'results': 'results'}
8452     def __init__(self, results=None, **unknown_fields):
8453         '''
8454         results : typing.Sequence[~ResolvedModeResult]
8455         '''
8456         self.results = [ResolvedModeResult.from_json(o) for o in results or []]
8457
8458
8459
8460 class Resource(Type):
8461     _toSchema = {'application': 'application', 'charmresource': 'CharmResource', 'id_': 'id', 'pending_id': 'pending-id', 'timestamp': 'timestamp', 'username': 'username'}
8462     _toPy = {'CharmResource': 'charmresource', 'application': 'application', 'id': 'id_', 'pending-id': 'pending_id', 'timestamp': 'timestamp', 'username': 'username'}
8463     def __init__(self, charmresource=None, application=None, id_=None, pending_id=None, timestamp=None, username=None, **unknown_fields):
8464         '''
8465         charmresource : CharmResource
8466         application : str
8467         id_ : str
8468         pending_id : str
8469         timestamp : str
8470         username : str
8471         '''
8472         self.charmresource = CharmResource.from_json(charmresource) if charmresource else None
8473         self.application = application
8474         self.id_ = id_
8475         self.pending_id = pending_id
8476         self.timestamp = timestamp
8477         self.username = username
8478
8479
8480
8481 class ResourceResult(Type):
8482     _toSchema = {'errorresult': 'ErrorResult', 'resource': 'resource'}
8483     _toPy = {'ErrorResult': 'errorresult', 'resource': 'resource'}
8484     def __init__(self, errorresult=None, resource=None, **unknown_fields):
8485         '''
8486         errorresult : ErrorResult
8487         resource : Resource
8488         '''
8489         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
8490         self.resource = Resource.from_json(resource) if resource else None
8491
8492
8493
8494 class ResourcesResult(Type):
8495     _toSchema = {'charm_store_resources': 'charm-store-resources', 'errorresult': 'ErrorResult', 'resources': 'resources', 'unit_resources': 'unit-resources'}
8496     _toPy = {'ErrorResult': 'errorresult', 'charm-store-resources': 'charm_store_resources', 'resources': 'resources', 'unit-resources': 'unit_resources'}
8497     def __init__(self, errorresult=None, charm_store_resources=None, resources=None, unit_resources=None, **unknown_fields):
8498         '''
8499         errorresult : ErrorResult
8500         charm_store_resources : typing.Sequence[~CharmResource]
8501         resources : typing.Sequence[~Resource]
8502         unit_resources : typing.Sequence[~UnitResources]
8503         '''
8504         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
8505         self.charm_store_resources = [CharmResource.from_json(o) for o in charm_store_resources or []]
8506         self.resources = [Resource.from_json(o) for o in resources or []]
8507         self.unit_resources = [UnitResources.from_json(o) for o in unit_resources or []]
8508
8509
8510
8511 class ResourcesResults(Type):
8512     _toSchema = {'results': 'results'}
8513     _toPy = {'results': 'results'}
8514     def __init__(self, results=None, **unknown_fields):
8515         '''
8516         results : typing.Sequence[~ResourcesResult]
8517         '''
8518         self.results = [ResourcesResult.from_json(o) for o in results or []]
8519
8520
8521
8522 class RestoreArgs(Type):
8523     _toSchema = {'backup_id': 'backup-id'}
8524     _toPy = {'backup-id': 'backup_id'}
8525     def __init__(self, backup_id=None, **unknown_fields):
8526         '''
8527         backup_id : str
8528         '''
8529         self.backup_id = backup_id
8530
8531
8532
8533 class ResumeReplicationParams(Type):
8534     _toSchema = {'members': 'members'}
8535     _toPy = {'members': 'members'}
8536     def __init__(self, members=None, **unknown_fields):
8537         '''
8538         members : typing.Sequence[~Member]
8539         '''
8540         self.members = [Member.from_json(o) for o in members or []]
8541
8542
8543
8544 class RetryStrategy(Type):
8545     _toSchema = {'jitter_retry_time': 'jitter-retry-time', 'max_retry_time': 'max-retry-time', 'min_retry_time': 'min-retry-time', 'retry_time_factor': 'retry-time-factor', 'should_retry': 'should-retry'}
8546     _toPy = {'jitter-retry-time': 'jitter_retry_time', 'max-retry-time': 'max_retry_time', 'min-retry-time': 'min_retry_time', 'retry-time-factor': 'retry_time_factor', 'should-retry': 'should_retry'}
8547     def __init__(self, jitter_retry_time=None, max_retry_time=None, min_retry_time=None, retry_time_factor=None, should_retry=None, **unknown_fields):
8548         '''
8549         jitter_retry_time : bool
8550         max_retry_time : int
8551         min_retry_time : int
8552         retry_time_factor : int
8553         should_retry : bool
8554         '''
8555         self.jitter_retry_time = jitter_retry_time
8556         self.max_retry_time = max_retry_time
8557         self.min_retry_time = min_retry_time
8558         self.retry_time_factor = retry_time_factor
8559         self.should_retry = should_retry
8560
8561
8562
8563 class RetryStrategyResult(Type):
8564     _toSchema = {'error': 'error', 'result': 'result'}
8565     _toPy = {'error': 'error', 'result': 'result'}
8566     def __init__(self, error=None, result=None, **unknown_fields):
8567         '''
8568         error : Error
8569         result : RetryStrategy
8570         '''
8571         self.error = Error.from_json(error) if error else None
8572         self.result = RetryStrategy.from_json(result) if result else None
8573
8574
8575
8576 class RetryStrategyResults(Type):
8577     _toSchema = {'results': 'results'}
8578     _toPy = {'results': 'results'}
8579     def __init__(self, results=None, **unknown_fields):
8580         '''
8581         results : typing.Sequence[~RetryStrategyResult]
8582         '''
8583         self.results = [RetryStrategyResult.from_json(o) for o in results or []]
8584
8585
8586
8587 class RevokeCredentialArg(Type):
8588     _toSchema = {'force': 'force', 'tag': 'tag'}
8589     _toPy = {'force': 'force', 'tag': 'tag'}
8590     def __init__(self, force=None, tag=None, **unknown_fields):
8591         '''
8592         force : bool
8593         tag : str
8594         '''
8595         self.force = force
8596         self.tag = tag
8597
8598
8599
8600 class RevokeCredentialArgs(Type):
8601     _toSchema = {'credentials': 'credentials'}
8602     _toPy = {'credentials': 'credentials'}
8603     def __init__(self, credentials=None, **unknown_fields):
8604         '''
8605         credentials : typing.Sequence[~RevokeCredentialArg]
8606         '''
8607         self.credentials = [RevokeCredentialArg.from_json(o) for o in credentials or []]
8608
8609
8610
8611 class RunParams(Type):
8612     _toSchema = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
8613     _toPy = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
8614     def __init__(self, applications=None, commands=None, machines=None, timeout=None, units=None, **unknown_fields):
8615         '''
8616         applications : typing.Sequence[str]
8617         commands : str
8618         machines : typing.Sequence[str]
8619         timeout : int
8620         units : typing.Sequence[str]
8621         '''
8622         self.applications = applications
8623         self.commands = commands
8624         self.machines = machines
8625         self.timeout = timeout
8626         self.units = units
8627
8628
8629
8630 class SSHAddressResult(Type):
8631     _toSchema = {'address': 'address', 'error': 'error'}
8632     _toPy = {'address': 'address', 'error': 'error'}
8633     def __init__(self, address=None, error=None, **unknown_fields):
8634         '''
8635         address : str
8636         error : Error
8637         '''
8638         self.address = address
8639         self.error = Error.from_json(error) if error else None
8640
8641
8642
8643 class SSHAddressResults(Type):
8644     _toSchema = {'results': 'results'}
8645     _toPy = {'results': 'results'}
8646     def __init__(self, results=None, **unknown_fields):
8647         '''
8648         results : typing.Sequence[~SSHAddressResult]
8649         '''
8650         self.results = [SSHAddressResult.from_json(o) for o in results or []]
8651
8652
8653
8654 class SSHAddressesResult(Type):
8655     _toSchema = {'addresses': 'addresses', 'error': 'error'}
8656     _toPy = {'addresses': 'addresses', 'error': 'error'}
8657     def __init__(self, addresses=None, error=None, **unknown_fields):
8658         '''
8659         addresses : typing.Sequence[str]
8660         error : Error
8661         '''
8662         self.addresses = addresses
8663         self.error = Error.from_json(error) if error else None
8664
8665
8666
8667 class SSHAddressesResults(Type):
8668     _toSchema = {'results': 'results'}
8669     _toPy = {'results': 'results'}
8670     def __init__(self, results=None, **unknown_fields):
8671         '''
8672         results : typing.Sequence[~SSHAddressesResult]
8673         '''
8674         self.results = [SSHAddressesResult.from_json(o) for o in results or []]
8675
8676
8677
8678 class SSHHostKeySet(Type):
8679     _toSchema = {'entity_keys': 'entity-keys'}
8680     _toPy = {'entity-keys': 'entity_keys'}
8681     def __init__(self, entity_keys=None, **unknown_fields):
8682         '''
8683         entity_keys : typing.Sequence[~SSHHostKeys]
8684         '''
8685         self.entity_keys = [SSHHostKeys.from_json(o) for o in entity_keys or []]
8686
8687
8688
8689 class SSHHostKeys(Type):
8690     _toSchema = {'public_keys': 'public-keys', 'tag': 'tag'}
8691     _toPy = {'public-keys': 'public_keys', 'tag': 'tag'}
8692     def __init__(self, public_keys=None, tag=None, **unknown_fields):
8693         '''
8694         public_keys : typing.Sequence[str]
8695         tag : str
8696         '''
8697         self.public_keys = public_keys
8698         self.tag = tag
8699
8700
8701
8702 class SSHProxyResult(Type):
8703     _toSchema = {'use_proxy': 'use-proxy'}
8704     _toPy = {'use-proxy': 'use_proxy'}
8705     def __init__(self, use_proxy=None, **unknown_fields):
8706         '''
8707         use_proxy : bool
8708         '''
8709         self.use_proxy = use_proxy
8710
8711
8712
8713 class SSHPublicKeysResult(Type):
8714     _toSchema = {'error': 'error', 'public_keys': 'public-keys'}
8715     _toPy = {'error': 'error', 'public-keys': 'public_keys'}
8716     def __init__(self, error=None, public_keys=None, **unknown_fields):
8717         '''
8718         error : Error
8719         public_keys : typing.Sequence[str]
8720         '''
8721         self.error = Error.from_json(error) if error else None
8722         self.public_keys = public_keys
8723
8724
8725
8726 class SSHPublicKeysResults(Type):
8727     _toSchema = {'results': 'results'}
8728     _toPy = {'results': 'results'}
8729     def __init__(self, results=None, **unknown_fields):
8730         '''
8731         results : typing.Sequence[~SSHPublicKeysResult]
8732         '''
8733         self.results = [SSHPublicKeysResult.from_json(o) for o in results or []]
8734
8735
8736
8737 class ScaleApplicationInfo(Type):
8738     _toSchema = {'num_units': 'num-units'}
8739     _toPy = {'num-units': 'num_units'}
8740     def __init__(self, num_units=None, **unknown_fields):
8741         '''
8742         num_units : int
8743         '''
8744         self.num_units = num_units
8745
8746
8747
8748 class ScaleApplicationParams(Type):
8749     _toSchema = {'application_tag': 'application-tag', 'scale': 'scale', 'scale_change': 'scale-change'}
8750     _toPy = {'application-tag': 'application_tag', 'scale': 'scale', 'scale-change': 'scale_change'}
8751     def __init__(self, application_tag=None, scale=None, scale_change=None, **unknown_fields):
8752         '''
8753         application_tag : str
8754         scale : int
8755         scale_change : int
8756         '''
8757         self.application_tag = application_tag
8758         self.scale = scale
8759         self.scale_change = scale_change
8760
8761
8762
8763 class ScaleApplicationResult(Type):
8764     _toSchema = {'error': 'error', 'info': 'info'}
8765     _toPy = {'error': 'error', 'info': 'info'}
8766     def __init__(self, error=None, info=None, **unknown_fields):
8767         '''
8768         error : Error
8769         info : ScaleApplicationInfo
8770         '''
8771         self.error = Error.from_json(error) if error else None
8772         self.info = ScaleApplicationInfo.from_json(info) if info else None
8773
8774
8775
8776 class ScaleApplicationResults(Type):
8777     _toSchema = {'results': 'results'}
8778     _toPy = {'results': 'results'}
8779     def __init__(self, results=None, **unknown_fields):
8780         '''
8781         results : typing.Sequence[~ScaleApplicationResult]
8782         '''
8783         self.results = [ScaleApplicationResult.from_json(o) for o in results or []]
8784
8785
8786
8787 class ScaleApplicationsParams(Type):
8788     _toSchema = {'applications': 'applications'}
8789     _toPy = {'applications': 'applications'}
8790     def __init__(self, applications=None, **unknown_fields):
8791         '''
8792         applications : typing.Sequence[~ScaleApplicationParams]
8793         '''
8794         self.applications = [ScaleApplicationParams.from_json(o) for o in applications or []]
8795
8796
8797
8798 class SerializedModel(Type):
8799     _toSchema = {'bytes_': 'bytes', 'charms': 'charms', 'tools': 'tools'}
8800     _toPy = {'bytes': 'bytes_', 'charms': 'charms', 'tools': 'tools'}
8801     def __init__(self, bytes_=None, charms=None, tools=None, **unknown_fields):
8802         '''
8803         bytes_ : typing.Sequence[int]
8804         charms : typing.Sequence[str]
8805         tools : typing.Sequence[~SerializedModelTools]
8806         '''
8807         self.bytes_ = bytes_
8808         self.charms = charms
8809         self.tools = [SerializedModelTools.from_json(o) for o in tools or []]
8810
8811
8812
8813 class SerializedModelResource(Type):
8814     _toSchema = {'application': 'application', 'application_revision': 'application-revision', 'charmstore_revision': 'charmstore-revision', 'name': 'name', 'unit_revisions': 'unit-revisions'}
8815     _toPy = {'application': 'application', 'application-revision': 'application_revision', 'charmstore-revision': 'charmstore_revision', 'name': 'name', 'unit-revisions': 'unit_revisions'}
8816     def __init__(self, application=None, application_revision=None, charmstore_revision=None, name=None, unit_revisions=None, **unknown_fields):
8817         '''
8818         application : str
8819         application_revision : SerializedModelResourceRevision
8820         charmstore_revision : SerializedModelResourceRevision
8821         name : str
8822         unit_revisions : typing.Mapping[str, ~SerializedModelResourceRevision]
8823         '''
8824         self.application = application
8825         self.application_revision = SerializedModelResourceRevision.from_json(application_revision) if application_revision else None
8826         self.charmstore_revision = SerializedModelResourceRevision.from_json(charmstore_revision) if charmstore_revision else None
8827         self.name = name
8828         self.unit_revisions = unit_revisions
8829
8830
8831
8832 class SerializedModelResourceRevision(Type):
8833     _toSchema = {'description': 'description', 'fingerprint': 'fingerprint', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'timestamp': 'timestamp', 'type_': 'type', 'username': 'username'}
8834     _toPy = {'description': 'description', 'fingerprint': 'fingerprint', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'timestamp': 'timestamp', 'type': 'type_', 'username': 'username'}
8835     def __init__(self, description=None, fingerprint=None, origin=None, path=None, revision=None, size=None, timestamp=None, type_=None, username=None, **unknown_fields):
8836         '''
8837         description : str
8838         fingerprint : str
8839         origin : str
8840         path : str
8841         revision : int
8842         size : int
8843         timestamp : str
8844         type_ : str
8845         username : str
8846         '''
8847         self.description = description
8848         self.fingerprint = fingerprint
8849         self.origin = origin
8850         self.path = path
8851         self.revision = revision
8852         self.size = size
8853         self.timestamp = timestamp
8854         self.type_ = type_
8855         self.username = username
8856
8857
8858
8859 class SerializedModelTools(Type):
8860     _toSchema = {'uri': 'uri', 'version': 'version'}
8861     _toPy = {'uri': 'uri', 'version': 'version'}
8862     def __init__(self, uri=None, version=None, **unknown_fields):
8863         '''
8864         uri : str
8865         version : str
8866         '''
8867         self.uri = uri
8868         self.version = version
8869
8870
8871
8872 class SetConstraints(Type):
8873     _toSchema = {'application': 'application', 'constraints': 'constraints'}
8874     _toPy = {'application': 'application', 'constraints': 'constraints'}
8875     def __init__(self, application=None, constraints=None, **unknown_fields):
8876         '''
8877         application : str
8878         constraints : Value
8879         '''
8880         self.application = application
8881         self.constraints = Value.from_json(constraints) if constraints else None
8882
8883
8884
8885 class SetExternalControllerInfoParams(Type):
8886     _toSchema = {'info': 'info'}
8887     _toPy = {'info': 'info'}
8888     def __init__(self, info=None, **unknown_fields):
8889         '''
8890         info : ExternalControllerInfo
8891         '''
8892         self.info = ExternalControllerInfo.from_json(info) if info else None
8893
8894
8895
8896 class SetExternalControllersInfoParams(Type):
8897     _toSchema = {'controllers': 'controllers'}
8898     _toPy = {'controllers': 'controllers'}
8899     def __init__(self, controllers=None, **unknown_fields):
8900         '''
8901         controllers : typing.Sequence[~SetExternalControllerInfoParams]
8902         '''
8903         self.controllers = [SetExternalControllerInfoParams.from_json(o) for o in controllers or []]
8904
8905
8906
8907 class SetMachineBlockDevices(Type):
8908     _toSchema = {'machine_block_devices': 'machine-block-devices'}
8909     _toPy = {'machine-block-devices': 'machine_block_devices'}
8910     def __init__(self, machine_block_devices=None, **unknown_fields):
8911         '''
8912         machine_block_devices : typing.Sequence[~MachineBlockDevices]
8913         '''
8914         self.machine_block_devices = [MachineBlockDevices.from_json(o) for o in machine_block_devices or []]
8915
8916
8917
8918 class SetMachineNetworkConfig(Type):
8919     _toSchema = {'config': 'config', 'tag': 'tag'}
8920     _toPy = {'config': 'config', 'tag': 'tag'}
8921     def __init__(self, config=None, tag=None, **unknown_fields):
8922         '''
8923         config : typing.Sequence[~NetworkConfig]
8924         tag : str
8925         '''
8926         self.config = [NetworkConfig.from_json(o) for o in config or []]
8927         self.tag = tag
8928
8929
8930
8931 class SetMachinesAddresses(Type):
8932     _toSchema = {'machine_addresses': 'machine-addresses'}
8933     _toPy = {'machine-addresses': 'machine_addresses'}
8934     def __init__(self, machine_addresses=None, **unknown_fields):
8935         '''
8936         machine_addresses : typing.Sequence[~MachineAddresses]
8937         '''
8938         self.machine_addresses = [MachineAddresses.from_json(o) for o in machine_addresses or []]
8939
8940
8941
8942 class SetMigrationPhaseArgs(Type):
8943     _toSchema = {'phase': 'phase'}
8944     _toPy = {'phase': 'phase'}
8945     def __init__(self, phase=None, **unknown_fields):
8946         '''
8947         phase : str
8948         '''
8949         self.phase = phase
8950
8951
8952
8953 class SetMigrationStatusMessageArgs(Type):
8954     _toSchema = {'message': 'message'}
8955     _toPy = {'message': 'message'}
8956     def __init__(self, message=None, **unknown_fields):
8957         '''
8958         message : str
8959         '''
8960         self.message = message
8961
8962
8963
8964 class SetModelAgentVersion(Type):
8965     _toSchema = {'version': 'version'}
8966     _toPy = {'version': 'version'}
8967     def __init__(self, version=None, **unknown_fields):
8968         '''
8969         version : Number
8970         '''
8971         self.version = Number.from_json(version) if version else None
8972
8973
8974
8975 class SetModelDefaults(Type):
8976     _toSchema = {'config': 'config'}
8977     _toPy = {'config': 'config'}
8978     def __init__(self, config=None, **unknown_fields):
8979         '''
8980         config : typing.Sequence[~ModelDefaultValues]
8981         '''
8982         self.config = [ModelDefaultValues.from_json(o) for o in config or []]
8983
8984
8985
8986 class SetModelEnvironVersion(Type):
8987     _toSchema = {'model_tag': 'model-tag', 'version': 'version'}
8988     _toPy = {'model-tag': 'model_tag', 'version': 'version'}
8989     def __init__(self, model_tag=None, version=None, **unknown_fields):
8990         '''
8991         model_tag : str
8992         version : int
8993         '''
8994         self.model_tag = model_tag
8995         self.version = version
8996
8997
8998
8999 class SetModelEnvironVersions(Type):
9000     _toSchema = {'models': 'models'}
9001     _toPy = {'models': 'models'}
9002     def __init__(self, models=None, **unknown_fields):
9003         '''
9004         models : typing.Sequence[~SetModelEnvironVersion]
9005         '''
9006         self.models = [SetModelEnvironVersion.from_json(o) for o in models or []]
9007
9008
9009
9010 class SetPayloadStatusArg(Type):
9011     _toSchema = {'entity': 'Entity', 'status': 'status'}
9012     _toPy = {'Entity': 'entity', 'status': 'status'}
9013     def __init__(self, entity=None, status=None, **unknown_fields):
9014         '''
9015         entity : Entity
9016         status : str
9017         '''
9018         self.entity = Entity.from_json(entity) if entity else None
9019         self.status = status
9020
9021
9022
9023 class SetPayloadStatusArgs(Type):
9024     _toSchema = {'args': 'args'}
9025     _toPy = {'args': 'args'}
9026     def __init__(self, args=None, **unknown_fields):
9027         '''
9028         args : typing.Sequence[~SetPayloadStatusArg]
9029         '''
9030         self.args = [SetPayloadStatusArg.from_json(o) for o in args or []]
9031
9032
9033
9034 class SetPodSpecParams(Type):
9035     _toSchema = {'specs': 'specs'}
9036     _toPy = {'specs': 'specs'}
9037     def __init__(self, specs=None, **unknown_fields):
9038         '''
9039         specs : typing.Sequence[~EntityString]
9040         '''
9041         self.specs = [EntityString.from_json(o) for o in specs or []]
9042
9043
9044
9045 class SetProfileArg(Type):
9046     _toSchema = {'entity': 'entity', 'profiles': 'profiles'}
9047     _toPy = {'entity': 'entity', 'profiles': 'profiles'}
9048     def __init__(self, entity=None, profiles=None, **unknown_fields):
9049         '''
9050         entity : Entity
9051         profiles : typing.Sequence[str]
9052         '''
9053         self.entity = Entity.from_json(entity) if entity else None
9054         self.profiles = profiles
9055
9056
9057
9058 class SetProfileArgs(Type):
9059     _toSchema = {'args': 'args'}
9060     _toPy = {'args': 'args'}
9061     def __init__(self, args=None, **unknown_fields):
9062         '''
9063         args : typing.Sequence[~SetProfileArg]
9064         '''
9065         self.args = [SetProfileArg.from_json(o) for o in args or []]
9066
9067
9068
9069 class SetProfileUpgradeCompleteArg(Type):
9070     _toSchema = {'entity': 'entity', 'message': 'message'}
9071     _toPy = {'entity': 'entity', 'message': 'message'}
9072     def __init__(self, entity=None, message=None, **unknown_fields):
9073         '''
9074         entity : Entity
9075         message : str
9076         '''
9077         self.entity = Entity.from_json(entity) if entity else None
9078         self.message = message
9079
9080
9081
9082 class SetProfileUpgradeCompleteArgs(Type):
9083     _toSchema = {'args': 'args'}
9084     _toPy = {'args': 'args'}
9085     def __init__(self, args=None, **unknown_fields):
9086         '''
9087         args : typing.Sequence[~SetProfileUpgradeCompleteArg]
9088         '''
9089         self.args = [SetProfileUpgradeCompleteArg.from_json(o) for o in args or []]
9090
9091
9092
9093 class SetStatus(Type):
9094     _toSchema = {'entities': 'entities'}
9095     _toPy = {'entities': 'entities'}
9096     def __init__(self, entities=None, **unknown_fields):
9097         '''
9098         entities : typing.Sequence[~EntityStatusArgs]
9099         '''
9100         self.entities = [EntityStatusArgs.from_json(o) for o in entities or []]
9101
9102
9103
9104 class SetStatusArg(Type):
9105     _toSchema = {'entity': 'Entity', 'status': 'status'}
9106     _toPy = {'Entity': 'entity', 'status': 'status'}
9107     def __init__(self, entity=None, status=None, **unknown_fields):
9108         '''
9109         entity : Entity
9110         status : str
9111         '''
9112         self.entity = Entity.from_json(entity) if entity else None
9113         self.status = status
9114
9115
9116
9117 class SetStatusArgs(Type):
9118     _toSchema = {'args': 'args'}
9119     _toPy = {'args': 'args'}
9120     def __init__(self, args=None, **unknown_fields):
9121         '''
9122         args : typing.Sequence[~SetStatusArg]
9123         '''
9124         self.args = [SetStatusArg.from_json(o) for o in args or []]
9125
9126
9127
9128 class Settings(Type):
9129     _toSchema = {'ftp': 'Ftp', 'http': 'Http', 'https': 'Https', 'noproxy': 'NoProxy'}
9130     _toPy = {'Ftp': 'ftp', 'Http': 'http', 'Https': 'https', 'NoProxy': 'noproxy'}
9131     def __init__(self, ftp=None, http=None, https=None, noproxy=None, **unknown_fields):
9132         '''
9133         ftp : str
9134         http : str
9135         https : str
9136         noproxy : str
9137         '''
9138         self.ftp = ftp
9139         self.http = http
9140         self.https = https
9141         self.noproxy = noproxy
9142
9143
9144
9145 class SettingsResult(Type):
9146     _toSchema = {'error': 'error', 'settings': 'settings'}
9147     _toPy = {'error': 'error', 'settings': 'settings'}
9148     def __init__(self, error=None, settings=None, **unknown_fields):
9149         '''
9150         error : Error
9151         settings : typing.Mapping[str, str]
9152         '''
9153         self.error = Error.from_json(error) if error else None
9154         self.settings = settings
9155
9156
9157
9158 class SettingsResults(Type):
9159     _toSchema = {'results': 'results'}
9160     _toPy = {'results': 'results'}
9161     def __init__(self, results=None, **unknown_fields):
9162         '''
9163         results : typing.Sequence[~SettingsResult]
9164         '''
9165         self.results = [SettingsResult.from_json(o) for o in results or []]
9166
9167
9168
9169 class SingularClaim(Type):
9170     _toSchema = {'controller_tag': 'controller-tag', 'duration': 'duration', 'model_tag': 'model-tag'}
9171     _toPy = {'controller-tag': 'controller_tag', 'duration': 'duration', 'model-tag': 'model_tag'}
9172     def __init__(self, controller_tag=None, duration=None, model_tag=None, **unknown_fields):
9173         '''
9174         controller_tag : str
9175         duration : int
9176         model_tag : str
9177         '''
9178         self.controller_tag = controller_tag
9179         self.duration = duration
9180         self.model_tag = model_tag
9181
9182
9183
9184 class SingularClaims(Type):
9185     _toSchema = {'claims': 'claims'}
9186     _toPy = {'claims': 'claims'}
9187     def __init__(self, claims=None, **unknown_fields):
9188         '''
9189         claims : typing.Sequence[~SingularClaim]
9190         '''
9191         self.claims = [SingularClaim.from_json(o) for o in claims or []]
9192
9193
9194
9195 class Space(Type):
9196     _toSchema = {'error': 'error', 'name': 'name', 'subnets': 'subnets'}
9197     _toPy = {'error': 'error', 'name': 'name', 'subnets': 'subnets'}
9198     def __init__(self, error=None, name=None, subnets=None, **unknown_fields):
9199         '''
9200         error : Error
9201         name : str
9202         subnets : typing.Sequence[~Subnet]
9203         '''
9204         self.error = Error.from_json(error) if error else None
9205         self.name = name
9206         self.subnets = [Subnet.from_json(o) for o in subnets or []]
9207
9208
9209
9210 class SpaceResult(Type):
9211     _toSchema = {'error': 'error', 'tag': 'tag'}
9212     _toPy = {'error': 'error', 'tag': 'tag'}
9213     def __init__(self, error=None, tag=None, **unknown_fields):
9214         '''
9215         error : Error
9216         tag : str
9217         '''
9218         self.error = Error.from_json(error) if error else None
9219         self.tag = tag
9220
9221
9222
9223 class SpaceResults(Type):
9224     _toSchema = {'results': 'results'}
9225     _toPy = {'results': 'results'}
9226     def __init__(self, results=None, **unknown_fields):
9227         '''
9228         results : typing.Sequence[~SpaceResult]
9229         '''
9230         self.results = [SpaceResult.from_json(o) for o in results or []]
9231
9232
9233
9234 class StateServingInfo(Type):
9235     _toSchema = {'api_port': 'api-port', 'ca_private_key': 'ca-private-key', 'cert': 'cert', 'private_key': 'private-key', 'shared_secret': 'shared-secret', 'state_port': 'state-port', 'system_identity': 'system-identity'}
9236     _toPy = {'api-port': 'api_port', 'ca-private-key': 'ca_private_key', 'cert': 'cert', 'private-key': 'private_key', 'shared-secret': 'shared_secret', 'state-port': 'state_port', 'system-identity': 'system_identity'}
9237     def __init__(self, api_port=None, ca_private_key=None, cert=None, private_key=None, shared_secret=None, state_port=None, system_identity=None, **unknown_fields):
9238         '''
9239         api_port : int
9240         ca_private_key : str
9241         cert : str
9242         private_key : str
9243         shared_secret : str
9244         state_port : int
9245         system_identity : str
9246         '''
9247         self.api_port = api_port
9248         self.ca_private_key = ca_private_key
9249         self.cert = cert
9250         self.private_key = private_key
9251         self.shared_secret = shared_secret
9252         self.state_port = state_port
9253         self.system_identity = system_identity
9254
9255
9256
9257 class StatusHistoryFilter(Type):
9258     _toSchema = {'date': 'date', 'delta': 'delta', 'size': 'size'}
9259     _toPy = {'date': 'date', 'delta': 'delta', 'size': 'size'}
9260     def __init__(self, date=None, delta=None, size=None, **unknown_fields):
9261         '''
9262         date : str
9263         delta : int
9264         size : int
9265         '''
9266         self.date = date
9267         self.delta = delta
9268         self.size = size
9269
9270
9271
9272 class StatusHistoryPruneArgs(Type):
9273     _toSchema = {'max_history_mb': 'max-history-mb', 'max_history_time': 'max-history-time'}
9274     _toPy = {'max-history-mb': 'max_history_mb', 'max-history-time': 'max_history_time'}
9275     def __init__(self, max_history_mb=None, max_history_time=None, **unknown_fields):
9276         '''
9277         max_history_mb : int
9278         max_history_time : int
9279         '''
9280         self.max_history_mb = max_history_mb
9281         self.max_history_time = max_history_time
9282
9283
9284
9285 class StatusHistoryRequest(Type):
9286     _toSchema = {'filter_': 'filter', 'historykind': 'historyKind', 'size': 'size', 'tag': 'tag'}
9287     _toPy = {'filter': 'filter_', 'historyKind': 'historykind', 'size': 'size', 'tag': 'tag'}
9288     def __init__(self, filter_=None, historykind=None, size=None, tag=None, **unknown_fields):
9289         '''
9290         filter_ : StatusHistoryFilter
9291         historykind : str
9292         size : int
9293         tag : str
9294         '''
9295         self.filter_ = StatusHistoryFilter.from_json(filter_) if filter_ else None
9296         self.historykind = historykind
9297         self.size = size
9298         self.tag = tag
9299
9300
9301
9302 class StatusHistoryRequests(Type):
9303     _toSchema = {'requests': 'requests'}
9304     _toPy = {'requests': 'requests'}
9305     def __init__(self, requests=None, **unknown_fields):
9306         '''
9307         requests : typing.Sequence[~StatusHistoryRequest]
9308         '''
9309         self.requests = [StatusHistoryRequest.from_json(o) for o in requests or []]
9310
9311
9312
9313 class StatusHistoryResult(Type):
9314     _toSchema = {'error': 'error', 'history': 'history'}
9315     _toPy = {'error': 'error', 'history': 'history'}
9316     def __init__(self, error=None, history=None, **unknown_fields):
9317         '''
9318         error : Error
9319         history : History
9320         '''
9321         self.error = Error.from_json(error) if error else None
9322         self.history = History.from_json(history) if history else None
9323
9324
9325
9326 class StatusHistoryResults(Type):
9327     _toSchema = {'results': 'results'}
9328     _toPy = {'results': 'results'}
9329     def __init__(self, results=None, **unknown_fields):
9330         '''
9331         results : typing.Sequence[~StatusHistoryResult]
9332         '''
9333         self.results = [StatusHistoryResult.from_json(o) for o in results or []]
9334
9335
9336
9337 class StatusParams(Type):
9338     _toSchema = {'patterns': 'patterns'}
9339     _toPy = {'patterns': 'patterns'}
9340     def __init__(self, patterns=None, **unknown_fields):
9341         '''
9342         patterns : typing.Sequence[str]
9343         '''
9344         self.patterns = patterns
9345
9346
9347
9348 class StatusResult(Type):
9349     _toSchema = {'data': 'data', 'error': 'error', 'id_': 'id', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
9350     _toPy = {'data': 'data', 'error': 'error', 'id': 'id_', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
9351     def __init__(self, data=None, error=None, id_=None, info=None, life=None, since=None, status=None, **unknown_fields):
9352         '''
9353         data : typing.Mapping[str, typing.Any]
9354         error : Error
9355         id_ : str
9356         info : str
9357         life : str
9358         since : str
9359         status : str
9360         '''
9361         self.data = data
9362         self.error = Error.from_json(error) if error else None
9363         self.id_ = id_
9364         self.info = info
9365         self.life = life
9366         self.since = since
9367         self.status = status
9368
9369
9370
9371 class StatusResults(Type):
9372     _toSchema = {'results': 'results'}
9373     _toPy = {'results': 'results'}
9374     def __init__(self, results=None, **unknown_fields):
9375         '''
9376         results : typing.Sequence[~StatusResult]
9377         '''
9378         self.results = [StatusResult.from_json(o) for o in results or []]
9379
9380
9381
9382 class StorageAddParams(Type):
9383     _toSchema = {'name': 'name', 'storage': 'storage', 'unit': 'unit'}
9384     _toPy = {'name': 'name', 'storage': 'storage', 'unit': 'unit'}
9385     def __init__(self, name=None, storage=None, unit=None, **unknown_fields):
9386         '''
9387         name : str
9388         storage : StorageConstraints
9389         unit : str
9390         '''
9391         self.name = name
9392         self.storage = StorageConstraints.from_json(storage) if storage else None
9393         self.unit = unit
9394
9395
9396
9397 class StorageAttachment(Type):
9398     _toSchema = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner_tag': 'owner-tag', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
9399     _toPy = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner-tag': 'owner_tag', 'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
9400     def __init__(self, kind=None, life=None, location=None, owner_tag=None, storage_tag=None, unit_tag=None, **unknown_fields):
9401         '''
9402         kind : int
9403         life : str
9404         location : str
9405         owner_tag : str
9406         storage_tag : str
9407         unit_tag : str
9408         '''
9409         self.kind = kind
9410         self.life = life
9411         self.location = location
9412         self.owner_tag = owner_tag
9413         self.storage_tag = storage_tag
9414         self.unit_tag = unit_tag
9415
9416
9417
9418 class StorageAttachmentDetails(Type):
9419     _toSchema = {'location': 'location', 'machine_tag': 'machine-tag', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
9420     _toPy = {'location': 'location', 'machine-tag': 'machine_tag', 'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
9421     def __init__(self, location=None, machine_tag=None, storage_tag=None, unit_tag=None, **unknown_fields):
9422         '''
9423         location : str
9424         machine_tag : str
9425         storage_tag : str
9426         unit_tag : str
9427         '''
9428         self.location = location
9429         self.machine_tag = machine_tag
9430         self.storage_tag = storage_tag
9431         self.unit_tag = unit_tag
9432
9433
9434
9435 class StorageAttachmentId(Type):
9436     _toSchema = {'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
9437     _toPy = {'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
9438     def __init__(self, storage_tag=None, unit_tag=None, **unknown_fields):
9439         '''
9440         storage_tag : str
9441         unit_tag : str
9442         '''
9443         self.storage_tag = storage_tag
9444         self.unit_tag = unit_tag
9445
9446
9447
9448 class StorageAttachmentIds(Type):
9449     _toSchema = {'ids': 'ids'}
9450     _toPy = {'ids': 'ids'}
9451     def __init__(self, ids=None, **unknown_fields):
9452         '''
9453         ids : typing.Sequence[~StorageAttachmentId]
9454         '''
9455         self.ids = [StorageAttachmentId.from_json(o) for o in ids or []]
9456
9457
9458
9459 class StorageAttachmentIdsResult(Type):
9460     _toSchema = {'error': 'error', 'result': 'result'}
9461     _toPy = {'error': 'error', 'result': 'result'}
9462     def __init__(self, error=None, result=None, **unknown_fields):
9463         '''
9464         error : Error
9465         result : StorageAttachmentIds
9466         '''
9467         self.error = Error.from_json(error) if error else None
9468         self.result = StorageAttachmentIds.from_json(result) if result else None
9469
9470
9471
9472 class StorageAttachmentIdsResults(Type):
9473     _toSchema = {'results': 'results'}
9474     _toPy = {'results': 'results'}
9475     def __init__(self, results=None, **unknown_fields):
9476         '''
9477         results : typing.Sequence[~StorageAttachmentIdsResult]
9478         '''
9479         self.results = [StorageAttachmentIdsResult.from_json(o) for o in results or []]
9480
9481
9482
9483 class StorageAttachmentResult(Type):
9484     _toSchema = {'error': 'error', 'result': 'result'}
9485     _toPy = {'error': 'error', 'result': 'result'}
9486     def __init__(self, error=None, result=None, **unknown_fields):
9487         '''
9488         error : Error
9489         result : StorageAttachment
9490         '''
9491         self.error = Error.from_json(error) if error else None
9492         self.result = StorageAttachment.from_json(result) if result else None
9493
9494
9495
9496 class StorageAttachmentResults(Type):
9497     _toSchema = {'results': 'results'}
9498     _toPy = {'results': 'results'}
9499     def __init__(self, results=None, **unknown_fields):
9500         '''
9501         results : typing.Sequence[~StorageAttachmentResult]
9502         '''
9503         self.results = [StorageAttachmentResult.from_json(o) for o in results or []]
9504
9505
9506
9507 class StorageConstraints(Type):
9508     _toSchema = {'count': 'count', 'pool': 'pool', 'size': 'size'}
9509     _toPy = {'count': 'count', 'pool': 'pool', 'size': 'size'}
9510     def __init__(self, count=None, pool=None, size=None, **unknown_fields):
9511         '''
9512         count : int
9513         pool : str
9514         size : int
9515         '''
9516         self.count = count
9517         self.pool = pool
9518         self.size = size
9519
9520
9521
9522 class StorageDetails(Type):
9523     _toSchema = {'attachments': 'attachments', 'kind': 'kind', 'owner_tag': 'owner-tag', 'persistent': 'persistent', 'status': 'status', 'storage_tag': 'storage-tag'}
9524     _toPy = {'attachments': 'attachments', 'kind': 'kind', 'owner-tag': 'owner_tag', 'persistent': 'persistent', 'status': 'status', 'storage-tag': 'storage_tag'}
9525     def __init__(self, attachments=None, kind=None, owner_tag=None, persistent=None, status=None, storage_tag=None, **unknown_fields):
9526         '''
9527         attachments : typing.Mapping[str, ~StorageAttachmentDetails]
9528         kind : int
9529         owner_tag : str
9530         persistent : bool
9531         status : EntityStatus
9532         storage_tag : str
9533         '''
9534         self.attachments = attachments
9535         self.kind = kind
9536         self.owner_tag = owner_tag
9537         self.persistent = persistent
9538         self.status = EntityStatus.from_json(status) if status else None
9539         self.storage_tag = storage_tag
9540
9541
9542
9543 class StorageDetailsListResult(Type):
9544     _toSchema = {'error': 'error', 'result': 'result'}
9545     _toPy = {'error': 'error', 'result': 'result'}
9546     def __init__(self, error=None, result=None, **unknown_fields):
9547         '''
9548         error : Error
9549         result : typing.Sequence[~StorageDetails]
9550         '''
9551         self.error = Error.from_json(error) if error else None
9552         self.result = [StorageDetails.from_json(o) for o in result or []]
9553
9554
9555
9556 class StorageDetailsListResults(Type):
9557     _toSchema = {'results': 'results'}
9558     _toPy = {'results': 'results'}
9559     def __init__(self, results=None, **unknown_fields):
9560         '''
9561         results : typing.Sequence[~StorageDetailsListResult]
9562         '''
9563         self.results = [StorageDetailsListResult.from_json(o) for o in results or []]
9564
9565
9566
9567 class StorageDetailsResult(Type):
9568     _toSchema = {'error': 'error', 'result': 'result'}
9569     _toPy = {'error': 'error', 'result': 'result'}
9570     def __init__(self, error=None, result=None, **unknown_fields):
9571         '''
9572         error : Error
9573         result : StorageDetails
9574         '''
9575         self.error = Error.from_json(error) if error else None
9576         self.result = StorageDetails.from_json(result) if result else None
9577
9578
9579
9580 class StorageDetailsResults(Type):
9581     _toSchema = {'results': 'results'}
9582     _toPy = {'results': 'results'}
9583     def __init__(self, results=None, **unknown_fields):
9584         '''
9585         results : typing.Sequence[~StorageDetailsResult]
9586         '''
9587         self.results = [StorageDetailsResult.from_json(o) for o in results or []]
9588
9589
9590
9591 class StorageFilter(Type):
9592     _toSchema = {}
9593     _toPy = {}
9594     def __init__(self, **unknown_fields):
9595         '''
9596
9597         '''
9598         pass
9599
9600
9601
9602 class StorageFilters(Type):
9603     _toSchema = {'filters': 'filters'}
9604     _toPy = {'filters': 'filters'}
9605     def __init__(self, filters=None, **unknown_fields):
9606         '''
9607         filters : typing.Sequence[~StorageFilter]
9608         '''
9609         self.filters = [StorageFilter.from_json(o) for o in filters or []]
9610
9611
9612
9613 class StoragePool(Type):
9614     _toSchema = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
9615     _toPy = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
9616     def __init__(self, attrs=None, name=None, provider=None, **unknown_fields):
9617         '''
9618         attrs : typing.Mapping[str, typing.Any]
9619         name : str
9620         provider : str
9621         '''
9622         self.attrs = attrs
9623         self.name = name
9624         self.provider = provider
9625
9626
9627
9628 class StoragePoolFilter(Type):
9629     _toSchema = {'names': 'names', 'providers': 'providers'}
9630     _toPy = {'names': 'names', 'providers': 'providers'}
9631     def __init__(self, names=None, providers=None, **unknown_fields):
9632         '''
9633         names : typing.Sequence[str]
9634         providers : typing.Sequence[str]
9635         '''
9636         self.names = names
9637         self.providers = providers
9638
9639
9640
9641 class StoragePoolFilters(Type):
9642     _toSchema = {'filters': 'filters'}
9643     _toPy = {'filters': 'filters'}
9644     def __init__(self, filters=None, **unknown_fields):
9645         '''
9646         filters : typing.Sequence[~StoragePoolFilter]
9647         '''
9648         self.filters = [StoragePoolFilter.from_json(o) for o in filters or []]
9649
9650
9651
9652 class StoragePoolsResult(Type):
9653     _toSchema = {'error': 'error', 'storage_pools': 'storage-pools'}
9654     _toPy = {'error': 'error', 'storage-pools': 'storage_pools'}
9655     def __init__(self, error=None, storage_pools=None, **unknown_fields):
9656         '''
9657         error : Error
9658         storage_pools : typing.Sequence[~StoragePool]
9659         '''
9660         self.error = Error.from_json(error) if error else None
9661         self.storage_pools = [StoragePool.from_json(o) for o in storage_pools or []]
9662
9663
9664
9665 class StoragePoolsResults(Type):
9666     _toSchema = {'results': 'results'}
9667     _toPy = {'results': 'results'}
9668     def __init__(self, results=None, **unknown_fields):
9669         '''
9670         results : typing.Sequence[~StoragePoolsResult]
9671         '''
9672         self.results = [StoragePoolsResult.from_json(o) for o in results or []]
9673
9674
9675
9676 class StoragesAddParams(Type):
9677     _toSchema = {'storages': 'storages'}
9678     _toPy = {'storages': 'storages'}
9679     def __init__(self, storages=None, **unknown_fields):
9680         '''
9681         storages : typing.Sequence[~StorageAddParams]
9682         '''
9683         self.storages = [StorageAddParams.from_json(o) for o in storages or []]
9684
9685
9686
9687 class StringBoolResult(Type):
9688     _toSchema = {'error': 'error', 'ok': 'ok', 'result': 'result'}
9689     _toPy = {'error': 'error', 'ok': 'ok', 'result': 'result'}
9690     def __init__(self, error=None, ok=None, result=None, **unknown_fields):
9691         '''
9692         error : Error
9693         ok : bool
9694         result : str
9695         '''
9696         self.error = Error.from_json(error) if error else None
9697         self.ok = ok
9698         self.result = result
9699
9700
9701
9702 class StringBoolResults(Type):
9703     _toSchema = {'results': 'results'}
9704     _toPy = {'results': 'results'}
9705     def __init__(self, results=None, **unknown_fields):
9706         '''
9707         results : typing.Sequence[~StringBoolResult]
9708         '''
9709         self.results = [StringBoolResult.from_json(o) for o in results or []]
9710
9711
9712
9713 class StringResult(Type):
9714     _toSchema = {'error': 'error', 'result': 'result'}
9715     _toPy = {'error': 'error', 'result': 'result'}
9716     def __init__(self, error=None, result=None, **unknown_fields):
9717         '''
9718         error : Error
9719         result : str
9720         '''
9721         self.error = Error.from_json(error) if error else None
9722         self.result = result
9723
9724
9725
9726 class StringResults(Type):
9727     _toSchema = {'results': 'results'}
9728     _toPy = {'results': 'results'}
9729     def __init__(self, results=None, **unknown_fields):
9730         '''
9731         results : typing.Sequence[~StringResult]
9732         '''
9733         self.results = [StringResult.from_json(o) for o in results or []]
9734
9735
9736
9737 class StringsResult(Type):
9738     _toSchema = {'error': 'error', 'result': 'result'}
9739     _toPy = {'error': 'error', 'result': 'result'}
9740     def __init__(self, error=None, result=None, **unknown_fields):
9741         '''
9742         error : Error
9743         result : typing.Sequence[str]
9744         '''
9745         self.error = Error.from_json(error) if error else None
9746         self.result = result
9747
9748
9749
9750 class StringsResults(Type):
9751     _toSchema = {'results': 'results'}
9752     _toPy = {'results': 'results'}
9753     def __init__(self, results=None, **unknown_fields):
9754         '''
9755         results : typing.Sequence[~StringsResult]
9756         '''
9757         self.results = [StringsResult.from_json(o) for o in results or []]
9758
9759
9760
9761 class StringsWatchResult(Type):
9762     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
9763     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
9764     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
9765         '''
9766         changes : typing.Sequence[str]
9767         error : Error
9768         watcher_id : str
9769         '''
9770         self.changes = changes
9771         self.error = Error.from_json(error) if error else None
9772         self.watcher_id = watcher_id
9773
9774
9775
9776 class StringsWatchResults(Type):
9777     _toSchema = {'results': 'results'}
9778     _toPy = {'results': 'results'}
9779     def __init__(self, results=None, **unknown_fields):
9780         '''
9781         results : typing.Sequence[~StringsWatchResult]
9782         '''
9783         self.results = [StringsWatchResult.from_json(o) for o in results or []]
9784
9785
9786
9787 class Subnet(Type):
9788     _toSchema = {'cidr': 'cidr', 'life': 'life', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'status': 'status', 'vlan_tag': 'vlan-tag', 'zones': 'zones'}
9789     _toPy = {'cidr': 'cidr', 'life': 'life', 'provider-id': 'provider_id', 'space-tag': 'space_tag', 'status': 'status', 'vlan-tag': 'vlan_tag', 'zones': 'zones'}
9790     def __init__(self, cidr=None, life=None, provider_id=None, space_tag=None, status=None, vlan_tag=None, zones=None, **unknown_fields):
9791         '''
9792         cidr : str
9793         life : str
9794         provider_id : str
9795         space_tag : str
9796         status : str
9797         vlan_tag : int
9798         zones : typing.Sequence[str]
9799         '''
9800         self.cidr = cidr
9801         self.life = life
9802         self.provider_id = provider_id
9803         self.space_tag = space_tag
9804         self.status = status
9805         self.vlan_tag = vlan_tag
9806         self.zones = zones
9807
9808
9809
9810 class SubnetsFilters(Type):
9811     _toSchema = {'space_tag': 'space-tag', 'zone': 'zone'}
9812     _toPy = {'space-tag': 'space_tag', 'zone': 'zone'}
9813     def __init__(self, space_tag=None, zone=None, **unknown_fields):
9814         '''
9815         space_tag : str
9816         zone : str
9817         '''
9818         self.space_tag = space_tag
9819         self.zone = zone
9820
9821
9822
9823 class TaggedCredential(Type):
9824     _toSchema = {'credential': 'credential', 'tag': 'tag'}
9825     _toPy = {'credential': 'credential', 'tag': 'tag'}
9826     def __init__(self, credential=None, tag=None, **unknown_fields):
9827         '''
9828         credential : CloudCredential
9829         tag : str
9830         '''
9831         self.credential = CloudCredential.from_json(credential) if credential else None
9832         self.tag = tag
9833
9834
9835
9836 class TaggedCredentials(Type):
9837     _toSchema = {'credentials': 'credentials'}
9838     _toPy = {'credentials': 'credentials'}
9839     def __init__(self, credentials=None, **unknown_fields):
9840         '''
9841         credentials : typing.Sequence[~TaggedCredential]
9842         '''
9843         self.credentials = [TaggedCredential.from_json(o) for o in credentials or []]
9844
9845
9846
9847 class TokenResult(Type):
9848     _toSchema = {'error': 'error', 'token': 'token'}
9849     _toPy = {'error': 'error', 'token': 'token'}
9850     def __init__(self, error=None, token=None, **unknown_fields):
9851         '''
9852         error : Error
9853         token : str
9854         '''
9855         self.error = Error.from_json(error) if error else None
9856         self.token = token
9857
9858
9859
9860 class TokenResults(Type):
9861     _toSchema = {'results': 'results'}
9862     _toPy = {'results': 'results'}
9863     def __init__(self, results=None, **unknown_fields):
9864         '''
9865         results : typing.Sequence[~TokenResult]
9866         '''
9867         self.results = [TokenResult.from_json(o) for o in results or []]
9868
9869
9870
9871 class Tools(Type):
9872     _toSchema = {'sha256': 'sha256', 'size': 'size', 'url': 'url', 'version': 'version'}
9873     _toPy = {'sha256': 'sha256', 'size': 'size', 'url': 'url', 'version': 'version'}
9874     def __init__(self, sha256=None, size=None, url=None, version=None, **unknown_fields):
9875         '''
9876         sha256 : str
9877         size : int
9878         url : str
9879         version : Binary
9880         '''
9881         self.sha256 = sha256
9882         self.size = size
9883         self.url = url
9884         self.version = Binary.from_json(version) if version else None
9885
9886
9887
9888 class ToolsResult(Type):
9889     _toSchema = {'disable_ssl_hostname_verification': 'disable-ssl-hostname-verification', 'error': 'error', 'tools': 'tools'}
9890     _toPy = {'disable-ssl-hostname-verification': 'disable_ssl_hostname_verification', 'error': 'error', 'tools': 'tools'}
9891     def __init__(self, disable_ssl_hostname_verification=None, error=None, tools=None, **unknown_fields):
9892         '''
9893         disable_ssl_hostname_verification : bool
9894         error : Error
9895         tools : typing.Sequence[~Tools]
9896         '''
9897         self.disable_ssl_hostname_verification = disable_ssl_hostname_verification
9898         self.error = Error.from_json(error) if error else None
9899         self.tools = [Tools.from_json(o) for o in tools or []]
9900
9901
9902
9903 class ToolsResults(Type):
9904     _toSchema = {'results': 'results'}
9905     _toPy = {'results': 'results'}
9906     def __init__(self, results=None, **unknown_fields):
9907         '''
9908         results : typing.Sequence[~ToolsResult]
9909         '''
9910         self.results = [ToolsResult.from_json(o) for o in results or []]
9911
9912
9913
9914 class TrackArgs(Type):
9915     _toSchema = {'payloads': 'payloads'}
9916     _toPy = {'payloads': 'payloads'}
9917     def __init__(self, payloads=None, **unknown_fields):
9918         '''
9919         payloads : typing.Sequence[~Payload]
9920         '''
9921         self.payloads = [Payload.from_json(o) for o in payloads or []]
9922
9923
9924
9925 class TrackPayloadArgs(Type):
9926     _toSchema = {'payloads': 'payloads'}
9927     _toPy = {'payloads': 'payloads'}
9928     def __init__(self, payloads=None, **unknown_fields):
9929         '''
9930         payloads : typing.Sequence[~Payload]
9931         '''
9932         self.payloads = [Payload.from_json(o) for o in payloads or []]
9933
9934
9935
9936 class UndertakerModelInfo(Type):
9937     _toSchema = {'global_name': 'global-name', 'is_system': 'is-system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
9938     _toPy = {'global-name': 'global_name', 'is-system': 'is_system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
9939     def __init__(self, global_name=None, is_system=None, life=None, name=None, uuid=None, **unknown_fields):
9940         '''
9941         global_name : str
9942         is_system : bool
9943         life : str
9944         name : str
9945         uuid : str
9946         '''
9947         self.global_name = global_name
9948         self.is_system = is_system
9949         self.life = life
9950         self.name = name
9951         self.uuid = uuid
9952
9953
9954
9955 class UndertakerModelInfoResult(Type):
9956     _toSchema = {'error': 'error', 'result': 'result'}
9957     _toPy = {'error': 'error', 'result': 'result'}
9958     def __init__(self, error=None, result=None, **unknown_fields):
9959         '''
9960         error : Error
9961         result : UndertakerModelInfo
9962         '''
9963         self.error = Error.from_json(error) if error else None
9964         self.result = UndertakerModelInfo.from_json(result) if result else None
9965
9966
9967
9968 class UnitNetworkConfig(Type):
9969     _toSchema = {'binding_name': 'binding-name', 'unit_tag': 'unit-tag'}
9970     _toPy = {'binding-name': 'binding_name', 'unit-tag': 'unit_tag'}
9971     def __init__(self, binding_name=None, unit_tag=None, **unknown_fields):
9972         '''
9973         binding_name : str
9974         unit_tag : str
9975         '''
9976         self.binding_name = binding_name
9977         self.unit_tag = unit_tag
9978
9979
9980
9981 class UnitNetworkConfigResult(Type):
9982     _toSchema = {'error': 'error', 'info': 'info'}
9983     _toPy = {'error': 'error', 'info': 'info'}
9984     def __init__(self, error=None, info=None, **unknown_fields):
9985         '''
9986         error : Error
9987         info : typing.Sequence[~NetworkConfig]
9988         '''
9989         self.error = Error.from_json(error) if error else None
9990         self.info = [NetworkConfig.from_json(o) for o in info or []]
9991
9992
9993
9994 class UnitNetworkConfigResults(Type):
9995     _toSchema = {'results': 'results'}
9996     _toPy = {'results': 'results'}
9997     def __init__(self, results=None, **unknown_fields):
9998         '''
9999         results : typing.Sequence[~UnitNetworkConfigResult]
10000         '''
10001         self.results = [UnitNetworkConfigResult.from_json(o) for o in results or []]
10002
10003
10004
10005 class UnitRefreshResult(Type):
10006     _toSchema = {'error': 'Error', 'life': 'Life', 'resolved': 'Resolved'}
10007     _toPy = {'Error': 'error', 'Life': 'life', 'Resolved': 'resolved'}
10008     def __init__(self, error=None, life=None, resolved=None, **unknown_fields):
10009         '''
10010         error : Error
10011         life : str
10012         resolved : str
10013         '''
10014         self.error = Error.from_json(error) if error else None
10015         self.life = life
10016         self.resolved = resolved
10017
10018
10019
10020 class UnitRefreshResults(Type):
10021     _toSchema = {'results': 'Results'}
10022     _toPy = {'Results': 'results'}
10023     def __init__(self, results=None, **unknown_fields):
10024         '''
10025         results : typing.Sequence[~UnitRefreshResult]
10026         '''
10027         self.results = [UnitRefreshResult.from_json(o) for o in results or []]
10028
10029
10030
10031 class UnitResourceResult(Type):
10032     _toSchema = {'errorresult': 'ErrorResult', 'resource': 'resource'}
10033     _toPy = {'ErrorResult': 'errorresult', 'resource': 'resource'}
10034     def __init__(self, errorresult=None, resource=None, **unknown_fields):
10035         '''
10036         errorresult : ErrorResult
10037         resource : Resource
10038         '''
10039         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
10040         self.resource = Resource.from_json(resource) if resource else None
10041
10042
10043
10044 class UnitResources(Type):
10045     _toSchema = {'download_progress': 'download-progress', 'entity': 'Entity', 'resources': 'resources'}
10046     _toPy = {'Entity': 'entity', 'download-progress': 'download_progress', 'resources': 'resources'}
10047     def __init__(self, entity=None, download_progress=None, resources=None, **unknown_fields):
10048         '''
10049         entity : Entity
10050         download_progress : typing.Mapping[str, int]
10051         resources : typing.Sequence[~Resource]
10052         '''
10053         self.entity = Entity.from_json(entity) if entity else None
10054         self.download_progress = download_progress
10055         self.resources = [Resource.from_json(o) for o in resources or []]
10056
10057
10058
10059 class UnitResourcesResult(Type):
10060     _toSchema = {'errorresult': 'ErrorResult', 'resources': 'resources'}
10061     _toPy = {'ErrorResult': 'errorresult', 'resources': 'resources'}
10062     def __init__(self, errorresult=None, resources=None, **unknown_fields):
10063         '''
10064         errorresult : ErrorResult
10065         resources : typing.Sequence[~UnitResourceResult]
10066         '''
10067         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
10068         self.resources = [UnitResourceResult.from_json(o) for o in resources or []]
10069
10070
10071
10072 class UnitSettings(Type):
10073     _toSchema = {'version': 'version'}
10074     _toPy = {'version': 'version'}
10075     def __init__(self, version=None, **unknown_fields):
10076         '''
10077         version : int
10078         '''
10079         self.version = version
10080
10081
10082
10083 class UnitStatus(Type):
10084     _toSchema = {'agent_status': 'agent-status', 'charm': 'charm', 'leader': 'leader', 'machine': 'machine', 'opened_ports': 'opened-ports', 'public_address': 'public-address', 'subordinates': 'subordinates', 'workload_status': 'workload-status', 'workload_version': 'workload-version'}
10085     _toPy = {'agent-status': 'agent_status', 'charm': 'charm', 'leader': 'leader', 'machine': 'machine', 'opened-ports': 'opened_ports', 'public-address': 'public_address', 'subordinates': 'subordinates', 'workload-status': 'workload_status', 'workload-version': 'workload_version'}
10086     def __init__(self, agent_status=None, charm=None, leader=None, machine=None, opened_ports=None, public_address=None, subordinates=None, workload_status=None, workload_version=None, **unknown_fields):
10087         '''
10088         agent_status : DetailedStatus
10089         charm : str
10090         leader : bool
10091         machine : str
10092         opened_ports : typing.Sequence[str]
10093         public_address : str
10094         subordinates : typing.Mapping[str, ~UnitStatus]
10095         workload_status : DetailedStatus
10096         workload_version : str
10097         '''
10098         self.agent_status = DetailedStatus.from_json(agent_status) if agent_status else None
10099         self.charm = charm
10100         self.leader = leader
10101         self.machine = machine
10102         self.opened_ports = opened_ports
10103         self.public_address = public_address
10104         self.subordinates = subordinates
10105         self.workload_status = DetailedStatus.from_json(workload_status) if workload_status else None
10106         self.workload_version = workload_version
10107
10108
10109
10110 class UnitsNetworkConfig(Type):
10111     _toSchema = {'args': 'args'}
10112     _toPy = {'args': 'args'}
10113     def __init__(self, args=None, **unknown_fields):
10114         '''
10115         args : typing.Sequence[~UnitNetworkConfig]
10116         '''
10117         self.args = [UnitNetworkConfig.from_json(o) for o in args or []]
10118
10119
10120
10121 class UnitsResolved(Type):
10122     _toSchema = {'all_': 'all', 'retry': 'retry', 'tags': 'tags'}
10123     _toPy = {'all': 'all_', 'retry': 'retry', 'tags': 'tags'}
10124     def __init__(self, all_=None, retry=None, tags=None, **unknown_fields):
10125         '''
10126         all_ : bool
10127         retry : bool
10128         tags : Entities
10129         '''
10130         self.all_ = all_
10131         self.retry = retry
10132         self.tags = Entities.from_json(tags) if tags else None
10133
10134
10135
10136 class UnsetModelDefaults(Type):
10137     _toSchema = {'keys': 'keys'}
10138     _toPy = {'keys': 'keys'}
10139     def __init__(self, keys=None, **unknown_fields):
10140         '''
10141         keys : typing.Sequence[~ModelUnsetKeys]
10142         '''
10143         self.keys = [ModelUnsetKeys.from_json(o) for o in keys or []]
10144
10145
10146
10147 class UpdateApplicationServiceArg(Type):
10148     _toSchema = {'addresses': 'addresses', 'application_tag': 'application-tag', 'provider_id': 'provider-id'}
10149     _toPy = {'addresses': 'addresses', 'application-tag': 'application_tag', 'provider-id': 'provider_id'}
10150     def __init__(self, addresses=None, application_tag=None, provider_id=None, **unknown_fields):
10151         '''
10152         addresses : typing.Sequence[~Address]
10153         application_tag : str
10154         provider_id : str
10155         '''
10156         self.addresses = [Address.from_json(o) for o in addresses or []]
10157         self.application_tag = application_tag
10158         self.provider_id = provider_id
10159
10160
10161
10162 class UpdateApplicationServiceArgs(Type):
10163     _toSchema = {'args': 'args'}
10164     _toPy = {'args': 'args'}
10165     def __init__(self, args=None, **unknown_fields):
10166         '''
10167         args : typing.Sequence[~UpdateApplicationServiceArg]
10168         '''
10169         self.args = [UpdateApplicationServiceArg.from_json(o) for o in args or []]
10170
10171
10172
10173 class UpdateApplicationUnitArgs(Type):
10174     _toSchema = {'args': 'args'}
10175     _toPy = {'args': 'args'}
10176     def __init__(self, args=None, **unknown_fields):
10177         '''
10178         args : typing.Sequence[~UpdateApplicationUnits]
10179         '''
10180         self.args = [UpdateApplicationUnits.from_json(o) for o in args or []]
10181
10182
10183
10184 class UpdateApplicationUnits(Type):
10185     _toSchema = {'application_tag': 'application-tag', 'units': 'units'}
10186     _toPy = {'application-tag': 'application_tag', 'units': 'units'}
10187     def __init__(self, application_tag=None, units=None, **unknown_fields):
10188         '''
10189         application_tag : str
10190         units : typing.Sequence[~ApplicationUnitParams]
10191         '''
10192         self.application_tag = application_tag
10193         self.units = [ApplicationUnitParams.from_json(o) for o in units or []]
10194
10195
10196
10197 class UpdateBehavior(Type):
10198     _toSchema = {'enable_os_refresh_update': 'enable-os-refresh-update', 'enable_os_upgrade': 'enable-os-upgrade'}
10199     _toPy = {'enable-os-refresh-update': 'enable_os_refresh_update', 'enable-os-upgrade': 'enable_os_upgrade'}
10200     def __init__(self, enable_os_refresh_update=None, enable_os_upgrade=None, **unknown_fields):
10201         '''
10202         enable_os_refresh_update : bool
10203         enable_os_upgrade : bool
10204         '''
10205         self.enable_os_refresh_update = enable_os_refresh_update
10206         self.enable_os_upgrade = enable_os_upgrade
10207
10208
10209
10210 class UpdateCloudCredential(Type):
10211     _toSchema = {'credential': 'credential', 'tag': 'tag'}
10212     _toPy = {'credential': 'credential', 'tag': 'tag'}
10213     def __init__(self, credential=None, tag=None, **unknown_fields):
10214         '''
10215         credential : CloudCredential
10216         tag : str
10217         '''
10218         self.credential = CloudCredential.from_json(credential) if credential else None
10219         self.tag = tag
10220
10221
10222
10223 class UpdateCloudCredentials(Type):
10224     _toSchema = {'credentials': 'credentials'}
10225     _toPy = {'credentials': 'credentials'}
10226     def __init__(self, credentials=None, **unknown_fields):
10227         '''
10228         credentials : typing.Sequence[~UpdateCloudCredential]
10229         '''
10230         self.credentials = [UpdateCloudCredential.from_json(o) for o in credentials or []]
10231
10232
10233
10234 class UpdateCredentialArgs(Type):
10235     _toSchema = {'credentials': 'credentials', 'force': 'force'}
10236     _toPy = {'credentials': 'credentials', 'force': 'force'}
10237     def __init__(self, credentials=None, force=None, **unknown_fields):
10238         '''
10239         credentials : typing.Sequence[~TaggedCredential]
10240         force : bool
10241         '''
10242         self.credentials = [TaggedCredential.from_json(o) for o in credentials or []]
10243         self.force = force
10244
10245
10246
10247 class UpdateCredentialModelResult(Type):
10248     _toSchema = {'errors': 'errors', 'name': 'name', 'uuid': 'uuid'}
10249     _toPy = {'errors': 'errors', 'name': 'name', 'uuid': 'uuid'}
10250     def __init__(self, errors=None, name=None, uuid=None, **unknown_fields):
10251         '''
10252         errors : typing.Sequence[~ErrorResult]
10253         name : str
10254         uuid : str
10255         '''
10256         self.errors = [ErrorResult.from_json(o) for o in errors or []]
10257         self.name = name
10258         self.uuid = uuid
10259
10260
10261
10262 class UpdateCredentialResult(Type):
10263     _toSchema = {'error': 'error', 'models': 'models', 'tag': 'tag'}
10264     _toPy = {'error': 'error', 'models': 'models', 'tag': 'tag'}
10265     def __init__(self, error=None, models=None, tag=None, **unknown_fields):
10266         '''
10267         error : Error
10268         models : typing.Sequence[~UpdateCredentialModelResult]
10269         tag : str
10270         '''
10271         self.error = Error.from_json(error) if error else None
10272         self.models = [UpdateCredentialModelResult.from_json(o) for o in models or []]
10273         self.tag = tag
10274
10275
10276
10277 class UpdateCredentialResults(Type):
10278     _toSchema = {'results': 'results'}
10279     _toPy = {'results': 'results'}
10280     def __init__(self, results=None, **unknown_fields):
10281         '''
10282         results : typing.Sequence[~UpdateCredentialResult]
10283         '''
10284         self.results = [UpdateCredentialResult.from_json(o) for o in results or []]
10285
10286
10287
10288 class UpdateSeriesArg(Type):
10289     _toSchema = {'force': 'force', 'series': 'series', 'tag': 'tag'}
10290     _toPy = {'force': 'force', 'series': 'series', 'tag': 'tag'}
10291     def __init__(self, force=None, series=None, tag=None, **unknown_fields):
10292         '''
10293         force : bool
10294         series : str
10295         tag : Entity
10296         '''
10297         self.force = force
10298         self.series = series
10299         self.tag = Entity.from_json(tag) if tag else None
10300
10301
10302
10303 class UpdateSeriesArgs(Type):
10304     _toSchema = {'args': 'args'}
10305     _toPy = {'args': 'args'}
10306     def __init__(self, args=None, **unknown_fields):
10307         '''
10308         args : typing.Sequence[~UpdateSeriesArg]
10309         '''
10310         self.args = [UpdateSeriesArg.from_json(o) for o in args or []]
10311
10312
10313
10314 class UpgradeMongoParams(Type):
10315     _toSchema = {'target': 'target'}
10316     _toPy = {'target': 'target'}
10317     def __init__(self, target=None, **unknown_fields):
10318         '''
10319         target : MongoVersion
10320         '''
10321         self.target = MongoVersion.from_json(target) if target else None
10322
10323
10324
10325 class UpgradeSeriesNotificationParam(Type):
10326     _toSchema = {'entity': 'entity', 'watcher_id': 'watcher-id'}
10327     _toPy = {'entity': 'entity', 'watcher-id': 'watcher_id'}
10328     def __init__(self, entity=None, watcher_id=None, **unknown_fields):
10329         '''
10330         entity : Entity
10331         watcher_id : str
10332         '''
10333         self.entity = Entity.from_json(entity) if entity else None
10334         self.watcher_id = watcher_id
10335
10336
10337
10338 class UpgradeSeriesNotificationParams(Type):
10339     _toSchema = {'params': 'params'}
10340     _toPy = {'params': 'params'}
10341     def __init__(self, params=None, **unknown_fields):
10342         '''
10343         params : typing.Sequence[~UpgradeSeriesNotificationParam]
10344         '''
10345         self.params = [UpgradeSeriesNotificationParam.from_json(o) for o in params or []]
10346
10347
10348
10349 class UpgradeSeriesStartUnitCompletionParam(Type):
10350     _toSchema = {'entities': 'entities', 'message': 'message'}
10351     _toPy = {'entities': 'entities', 'message': 'message'}
10352     def __init__(self, entities=None, message=None, **unknown_fields):
10353         '''
10354         entities : typing.Sequence[~Entity]
10355         message : str
10356         '''
10357         self.entities = [Entity.from_json(o) for o in entities or []]
10358         self.message = message
10359
10360
10361
10362 class UpgradeSeriesStatusParam(Type):
10363     _toSchema = {'entity': 'entity', 'message': 'message', 'status': 'status'}
10364     _toPy = {'entity': 'entity', 'message': 'message', 'status': 'status'}
10365     def __init__(self, entity=None, message=None, status=None, **unknown_fields):
10366         '''
10367         entity : Entity
10368         message : str
10369         status : str
10370         '''
10371         self.entity = Entity.from_json(entity) if entity else None
10372         self.message = message
10373         self.status = status
10374
10375
10376
10377 class UpgradeSeriesStatusParams(Type):
10378     _toSchema = {'params': 'params'}
10379     _toPy = {'params': 'params'}
10380     def __init__(self, params=None, **unknown_fields):
10381         '''
10382         params : typing.Sequence[~UpgradeSeriesStatusParam]
10383         '''
10384         self.params = [UpgradeSeriesStatusParam.from_json(o) for o in params or []]
10385
10386
10387
10388 class UpgradeSeriesStatusResult(Type):
10389     _toSchema = {'error': 'error', 'status': 'status'}
10390     _toPy = {'error': 'error', 'status': 'status'}
10391     def __init__(self, error=None, status=None, **unknown_fields):
10392         '''
10393         error : Error
10394         status : str
10395         '''
10396         self.error = Error.from_json(error) if error else None
10397         self.status = status
10398
10399
10400
10401 class UpgradeSeriesStatusResults(Type):
10402     _toSchema = {'results': 'results'}
10403     _toPy = {'results': 'results'}
10404     def __init__(self, results=None, **unknown_fields):
10405         '''
10406         results : typing.Sequence[~UpgradeSeriesStatusResult]
10407         '''
10408         self.results = [UpgradeSeriesStatusResult.from_json(o) for o in results or []]
10409
10410
10411
10412 class UpgradeSeriesUnitsResult(Type):
10413     _toSchema = {'error': 'error', 'unit_names': 'unit-names'}
10414     _toPy = {'error': 'error', 'unit-names': 'unit_names'}
10415     def __init__(self, error=None, unit_names=None, **unknown_fields):
10416         '''
10417         error : Error
10418         unit_names : typing.Sequence[str]
10419         '''
10420         self.error = Error.from_json(error) if error else None
10421         self.unit_names = unit_names
10422
10423
10424
10425 class UpgradeSeriesUnitsResults(Type):
10426     _toSchema = {'results': 'Results'}
10427     _toPy = {'Results': 'results'}
10428     def __init__(self, results=None, **unknown_fields):
10429         '''
10430         results : typing.Sequence[~UpgradeSeriesUnitsResult]
10431         '''
10432         self.results = [UpgradeSeriesUnitsResult.from_json(o) for o in results or []]
10433
10434
10435
10436 class UserAccess(Type):
10437     _toSchema = {'access': 'access', 'user_tag': 'user-tag'}
10438     _toPy = {'access': 'access', 'user-tag': 'user_tag'}
10439     def __init__(self, access=None, user_tag=None, **unknown_fields):
10440         '''
10441         access : str
10442         user_tag : str
10443         '''
10444         self.access = access
10445         self.user_tag = user_tag
10446
10447
10448
10449 class UserAccessResult(Type):
10450     _toSchema = {'error': 'error', 'result': 'result'}
10451     _toPy = {'error': 'error', 'result': 'result'}
10452     def __init__(self, error=None, result=None, **unknown_fields):
10453         '''
10454         error : Error
10455         result : UserAccess
10456         '''
10457         self.error = Error.from_json(error) if error else None
10458         self.result = UserAccess.from_json(result) if result else None
10459
10460
10461
10462 class UserAccessResults(Type):
10463     _toSchema = {'results': 'results'}
10464     _toPy = {'results': 'results'}
10465     def __init__(self, results=None, **unknown_fields):
10466         '''
10467         results : typing.Sequence[~UserAccessResult]
10468         '''
10469         self.results = [UserAccessResult.from_json(o) for o in results or []]
10470
10471
10472
10473 class UserCloud(Type):
10474     _toSchema = {'cloud_tag': 'cloud-tag', 'user_tag': 'user-tag'}
10475     _toPy = {'cloud-tag': 'cloud_tag', 'user-tag': 'user_tag'}
10476     def __init__(self, cloud_tag=None, user_tag=None, **unknown_fields):
10477         '''
10478         cloud_tag : str
10479         user_tag : str
10480         '''
10481         self.cloud_tag = cloud_tag
10482         self.user_tag = user_tag
10483
10484
10485
10486 class UserClouds(Type):
10487     _toSchema = {'user_clouds': 'user-clouds'}
10488     _toPy = {'user-clouds': 'user_clouds'}
10489     def __init__(self, user_clouds=None, **unknown_fields):
10490         '''
10491         user_clouds : typing.Sequence[~UserCloud]
10492         '''
10493         self.user_clouds = [UserCloud.from_json(o) for o in user_clouds or []]
10494
10495
10496
10497 class UserInfo(Type):
10498     _toSchema = {'access': 'access', 'created_by': 'created-by', 'date_created': 'date-created', 'disabled': 'disabled', 'display_name': 'display-name', 'last_connection': 'last-connection', 'username': 'username'}
10499     _toPy = {'access': 'access', 'created-by': 'created_by', 'date-created': 'date_created', 'disabled': 'disabled', 'display-name': 'display_name', 'last-connection': 'last_connection', 'username': 'username'}
10500     def __init__(self, access=None, created_by=None, date_created=None, disabled=None, display_name=None, last_connection=None, username=None, **unknown_fields):
10501         '''
10502         access : str
10503         created_by : str
10504         date_created : str
10505         disabled : bool
10506         display_name : str
10507         last_connection : str
10508         username : str
10509         '''
10510         self.access = access
10511         self.created_by = created_by
10512         self.date_created = date_created
10513         self.disabled = disabled
10514         self.display_name = display_name
10515         self.last_connection = last_connection
10516         self.username = username
10517
10518
10519
10520 class UserInfoRequest(Type):
10521     _toSchema = {'entities': 'entities', 'include_disabled': 'include-disabled'}
10522     _toPy = {'entities': 'entities', 'include-disabled': 'include_disabled'}
10523     def __init__(self, entities=None, include_disabled=None, **unknown_fields):
10524         '''
10525         entities : typing.Sequence[~Entity]
10526         include_disabled : bool
10527         '''
10528         self.entities = [Entity.from_json(o) for o in entities or []]
10529         self.include_disabled = include_disabled
10530
10531
10532
10533 class UserInfoResult(Type):
10534     _toSchema = {'error': 'error', 'result': 'result'}
10535     _toPy = {'error': 'error', 'result': 'result'}
10536     def __init__(self, error=None, result=None, **unknown_fields):
10537         '''
10538         error : Error
10539         result : UserInfo
10540         '''
10541         self.error = Error.from_json(error) if error else None
10542         self.result = UserInfo.from_json(result) if result else None
10543
10544
10545
10546 class UserInfoResults(Type):
10547     _toSchema = {'results': 'results'}
10548     _toPy = {'results': 'results'}
10549     def __init__(self, results=None, **unknown_fields):
10550         '''
10551         results : typing.Sequence[~UserInfoResult]
10552         '''
10553         self.results = [UserInfoResult.from_json(o) for o in results or []]
10554
10555
10556
10557 class UserModel(Type):
10558     _toSchema = {'last_connection': 'last-connection', 'model': 'model'}
10559     _toPy = {'last-connection': 'last_connection', 'model': 'model'}
10560     def __init__(self, last_connection=None, model=None, **unknown_fields):
10561         '''
10562         last_connection : str
10563         model : Model
10564         '''
10565         self.last_connection = last_connection
10566         self.model = Model.from_json(model) if model else None
10567
10568
10569
10570 class UserModelList(Type):
10571     _toSchema = {'user_models': 'user-models'}
10572     _toPy = {'user-models': 'user_models'}
10573     def __init__(self, user_models=None, **unknown_fields):
10574         '''
10575         user_models : typing.Sequence[~UserModel]
10576         '''
10577         self.user_models = [UserModel.from_json(o) for o in user_models or []]
10578
10579
10580
10581 class Value(Type):
10582     _toSchema = {'arch': 'arch', 'container': 'container', 'cores': 'cores', 'cpu_power': 'cpu-power', 'instance_type': 'instance-type', 'mem': 'mem', 'root_disk': 'root-disk', 'spaces': 'spaces', 'tags': 'tags', 'virt_type': 'virt-type'}
10583     _toPy = {'arch': 'arch', 'container': 'container', 'cores': 'cores', 'cpu-power': 'cpu_power', 'instance-type': 'instance_type', 'mem': 'mem', 'root-disk': 'root_disk', 'spaces': 'spaces', 'tags': 'tags', 'virt-type': 'virt_type'}
10584     def __init__(self, arch=None, container=None, cores=None, cpu_power=None, instance_type=None, mem=None, root_disk=None, spaces=None, tags=None, virt_type=None, **unknown_fields):
10585         '''
10586         arch : str
10587         container : str
10588         cores : int
10589         cpu_power : int
10590         instance_type : str
10591         mem : int
10592         root_disk : int
10593         spaces : typing.Sequence[str]
10594         tags : typing.Sequence[str]
10595         virt_type : str
10596         '''
10597         self.arch = arch
10598         self.container = container
10599         self.cores = cores
10600         self.cpu_power = cpu_power
10601         self.instance_type = instance_type
10602         self.mem = mem
10603         self.root_disk = root_disk
10604         self.spaces = spaces
10605         self.tags = tags
10606         self.virt_type = virt_type
10607
10608
10609
10610 class Version(Type):
10611     _toSchema = {'version': 'version'}
10612     _toPy = {'version': 'version'}
10613     def __init__(self, version=None, **unknown_fields):
10614         '''
10615         version : Binary
10616         '''
10617         self.version = Binary.from_json(version) if version else None
10618
10619
10620
10621 class VersionResult(Type):
10622     _toSchema = {'error': 'error', 'version': 'version'}
10623     _toPy = {'error': 'error', 'version': 'version'}
10624     def __init__(self, error=None, version=None, **unknown_fields):
10625         '''
10626         error : Error
10627         version : Number
10628         '''
10629         self.error = Error.from_json(error) if error else None
10630         self.version = Number.from_json(version) if version else None
10631
10632
10633
10634 class VersionResults(Type):
10635     _toSchema = {'results': 'results'}
10636     _toPy = {'results': 'results'}
10637     def __init__(self, results=None, **unknown_fields):
10638         '''
10639         results : typing.Sequence[~VersionResult]
10640         '''
10641         self.results = [VersionResult.from_json(o) for o in results or []]
10642
10643
10644
10645 class Volume(Type):
10646     _toSchema = {'info': 'info', 'volume_tag': 'volume-tag'}
10647     _toPy = {'info': 'info', 'volume-tag': 'volume_tag'}
10648     def __init__(self, info=None, volume_tag=None, **unknown_fields):
10649         '''
10650         info : VolumeInfo
10651         volume_tag : str
10652         '''
10653         self.info = VolumeInfo.from_json(info) if info else None
10654         self.volume_tag = volume_tag
10655
10656
10657
10658 class VolumeAttachment(Type):
10659     _toSchema = {'info': 'info', 'machine_tag': 'machine-tag', 'volume_tag': 'volume-tag'}
10660     _toPy = {'info': 'info', 'machine-tag': 'machine_tag', 'volume-tag': 'volume_tag'}
10661     def __init__(self, info=None, machine_tag=None, volume_tag=None, **unknown_fields):
10662         '''
10663         info : VolumeAttachmentInfo
10664         machine_tag : str
10665         volume_tag : str
10666         '''
10667         self.info = VolumeAttachmentInfo.from_json(info) if info else None
10668         self.machine_tag = machine_tag
10669         self.volume_tag = volume_tag
10670
10671
10672
10673 class VolumeAttachmentDetails(Type):
10674     _toSchema = {'life': 'life', 'volumeattachmentinfo': 'VolumeAttachmentInfo'}
10675     _toPy = {'VolumeAttachmentInfo': 'volumeattachmentinfo', 'life': 'life'}
10676     def __init__(self, volumeattachmentinfo=None, life=None, **unknown_fields):
10677         '''
10678         volumeattachmentinfo : VolumeAttachmentInfo
10679         life : str
10680         '''
10681         self.volumeattachmentinfo = VolumeAttachmentInfo.from_json(volumeattachmentinfo) if volumeattachmentinfo else None
10682         self.life = life
10683
10684
10685
10686 class VolumeAttachmentInfo(Type):
10687     _toSchema = {'bus_address': 'bus-address', 'device_link': 'device-link', 'device_name': 'device-name', 'read_only': 'read-only'}
10688     _toPy = {'bus-address': 'bus_address', 'device-link': 'device_link', 'device-name': 'device_name', 'read-only': 'read_only'}
10689     def __init__(self, bus_address=None, device_link=None, device_name=None, read_only=None, **unknown_fields):
10690         '''
10691         bus_address : str
10692         device_link : str
10693         device_name : str
10694         read_only : bool
10695         '''
10696         self.bus_address = bus_address
10697         self.device_link = device_link
10698         self.device_name = device_name
10699         self.read_only = read_only
10700
10701
10702
10703 class VolumeAttachmentParams(Type):
10704     _toSchema = {'instance_id': 'instance-id', 'machine_tag': 'machine-tag', 'provider': 'provider', 'read_only': 'read-only', 'volume_id': 'volume-id', 'volume_tag': 'volume-tag'}
10705     _toPy = {'instance-id': 'instance_id', 'machine-tag': 'machine_tag', 'provider': 'provider', 'read-only': 'read_only', 'volume-id': 'volume_id', 'volume-tag': 'volume_tag'}
10706     def __init__(self, instance_id=None, machine_tag=None, provider=None, read_only=None, volume_id=None, volume_tag=None, **unknown_fields):
10707         '''
10708         instance_id : str
10709         machine_tag : str
10710         provider : str
10711         read_only : bool
10712         volume_id : str
10713         volume_tag : str
10714         '''
10715         self.instance_id = instance_id
10716         self.machine_tag = machine_tag
10717         self.provider = provider
10718         self.read_only = read_only
10719         self.volume_id = volume_id
10720         self.volume_tag = volume_tag
10721
10722
10723
10724 class VolumeAttachmentParamsResult(Type):
10725     _toSchema = {'error': 'error', 'result': 'result'}
10726     _toPy = {'error': 'error', 'result': 'result'}
10727     def __init__(self, error=None, result=None, **unknown_fields):
10728         '''
10729         error : Error
10730         result : VolumeAttachmentParams
10731         '''
10732         self.error = Error.from_json(error) if error else None
10733         self.result = VolumeAttachmentParams.from_json(result) if result else None
10734
10735
10736
10737 class VolumeAttachmentParamsResults(Type):
10738     _toSchema = {'results': 'results'}
10739     _toPy = {'results': 'results'}
10740     def __init__(self, results=None, **unknown_fields):
10741         '''
10742         results : typing.Sequence[~VolumeAttachmentParamsResult]
10743         '''
10744         self.results = [VolumeAttachmentParamsResult.from_json(o) for o in results or []]
10745
10746
10747
10748 class VolumeAttachmentPlan(Type):
10749     _toSchema = {'block_device': 'block-device', 'life': 'life', 'machine_tag': 'machine-tag', 'plan_info': 'plan-info', 'volume_tag': 'volume-tag'}
10750     _toPy = {'block-device': 'block_device', 'life': 'life', 'machine-tag': 'machine_tag', 'plan-info': 'plan_info', 'volume-tag': 'volume_tag'}
10751     def __init__(self, block_device=None, life=None, machine_tag=None, plan_info=None, volume_tag=None, **unknown_fields):
10752         '''
10753         block_device : BlockDevice
10754         life : str
10755         machine_tag : str
10756         plan_info : VolumeAttachmentPlanInfo
10757         volume_tag : str
10758         '''
10759         self.block_device = BlockDevice.from_json(block_device) if block_device else None
10760         self.life = life
10761         self.machine_tag = machine_tag
10762         self.plan_info = VolumeAttachmentPlanInfo.from_json(plan_info) if plan_info else None
10763         self.volume_tag = volume_tag
10764
10765
10766
10767 class VolumeAttachmentPlanInfo(Type):
10768     _toSchema = {'device_attributes': 'device-attributes', 'device_type': 'device-type'}
10769     _toPy = {'device-attributes': 'device_attributes', 'device-type': 'device_type'}
10770     def __init__(self, device_attributes=None, device_type=None, **unknown_fields):
10771         '''
10772         device_attributes : typing.Mapping[str, str]
10773         device_type : str
10774         '''
10775         self.device_attributes = device_attributes
10776         self.device_type = device_type
10777
10778
10779
10780 class VolumeAttachmentPlanResult(Type):
10781     _toSchema = {'error': 'error', 'result': 'result'}
10782     _toPy = {'error': 'error', 'result': 'result'}
10783     def __init__(self, error=None, result=None, **unknown_fields):
10784         '''
10785         error : Error
10786         result : VolumeAttachmentPlan
10787         '''
10788         self.error = Error.from_json(error) if error else None
10789         self.result = VolumeAttachmentPlan.from_json(result) if result else None
10790
10791
10792
10793 class VolumeAttachmentPlanResults(Type):
10794     _toSchema = {'results': 'results'}
10795     _toPy = {'results': 'results'}
10796     def __init__(self, results=None, **unknown_fields):
10797         '''
10798         results : typing.Sequence[~VolumeAttachmentPlanResult]
10799         '''
10800         self.results = [VolumeAttachmentPlanResult.from_json(o) for o in results or []]
10801
10802
10803
10804 class VolumeAttachmentPlans(Type):
10805     _toSchema = {'volume_plans': 'volume-plans'}
10806     _toPy = {'volume-plans': 'volume_plans'}
10807     def __init__(self, volume_plans=None, **unknown_fields):
10808         '''
10809         volume_plans : typing.Sequence[~VolumeAttachmentPlan]
10810         '''
10811         self.volume_plans = [VolumeAttachmentPlan.from_json(o) for o in volume_plans or []]
10812
10813
10814
10815 class VolumeAttachmentResult(Type):
10816     _toSchema = {'error': 'error', 'result': 'result'}
10817     _toPy = {'error': 'error', 'result': 'result'}
10818     def __init__(self, error=None, result=None, **unknown_fields):
10819         '''
10820         error : Error
10821         result : VolumeAttachment
10822         '''
10823         self.error = Error.from_json(error) if error else None
10824         self.result = VolumeAttachment.from_json(result) if result else None
10825
10826
10827
10828 class VolumeAttachmentResults(Type):
10829     _toSchema = {'results': 'results'}
10830     _toPy = {'results': 'results'}
10831     def __init__(self, results=None, **unknown_fields):
10832         '''
10833         results : typing.Sequence[~VolumeAttachmentResult]
10834         '''
10835         self.results = [VolumeAttachmentResult.from_json(o) for o in results or []]
10836
10837
10838
10839 class VolumeAttachments(Type):
10840     _toSchema = {'volume_attachments': 'volume-attachments'}
10841     _toPy = {'volume-attachments': 'volume_attachments'}
10842     def __init__(self, volume_attachments=None, **unknown_fields):
10843         '''
10844         volume_attachments : typing.Sequence[~VolumeAttachment]
10845         '''
10846         self.volume_attachments = [VolumeAttachment.from_json(o) for o in volume_attachments or []]
10847
10848
10849
10850 class VolumeDetails(Type):
10851     _toSchema = {'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'volume_tag': 'volume-tag'}
10852     _toPy = {'info': 'info', 'machine-attachments': 'machine_attachments', 'status': 'status', 'storage': 'storage', 'volume-tag': 'volume_tag'}
10853     def __init__(self, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None, **unknown_fields):
10854         '''
10855         info : VolumeInfo
10856         machine_attachments : typing.Mapping[str, ~VolumeAttachmentInfo]
10857         status : EntityStatus
10858         storage : StorageDetails
10859         volume_tag : str
10860         '''
10861         self.info = VolumeInfo.from_json(info) if info else None
10862         self.machine_attachments = machine_attachments
10863         self.status = EntityStatus.from_json(status) if status else None
10864         self.storage = StorageDetails.from_json(storage) if storage else None
10865         self.volume_tag = volume_tag
10866
10867
10868
10869 class VolumeDetailsListResult(Type):
10870     _toSchema = {'error': 'error', 'result': 'result'}
10871     _toPy = {'error': 'error', 'result': 'result'}
10872     def __init__(self, error=None, result=None, **unknown_fields):
10873         '''
10874         error : Error
10875         result : typing.Sequence[~VolumeDetails]
10876         '''
10877         self.error = Error.from_json(error) if error else None
10878         self.result = [VolumeDetails.from_json(o) for o in result or []]
10879
10880
10881
10882 class VolumeDetailsListResults(Type):
10883     _toSchema = {'results': 'results'}
10884     _toPy = {'results': 'results'}
10885     def __init__(self, results=None, **unknown_fields):
10886         '''
10887         results : typing.Sequence[~VolumeDetailsListResult]
10888         '''
10889         self.results = [VolumeDetailsListResult.from_json(o) for o in results or []]
10890
10891
10892
10893 class VolumeFilter(Type):
10894     _toSchema = {'machines': 'machines'}
10895     _toPy = {'machines': 'machines'}
10896     def __init__(self, machines=None, **unknown_fields):
10897         '''
10898         machines : typing.Sequence[str]
10899         '''
10900         self.machines = machines
10901
10902
10903
10904 class VolumeFilters(Type):
10905     _toSchema = {'filters': 'filters'}
10906     _toPy = {'filters': 'filters'}
10907     def __init__(self, filters=None, **unknown_fields):
10908         '''
10909         filters : typing.Sequence[~VolumeFilter]
10910         '''
10911         self.filters = [VolumeFilter.from_json(o) for o in filters or []]
10912
10913
10914
10915 class VolumeInfo(Type):
10916     _toSchema = {'hardware_id': 'hardware-id', 'persistent': 'persistent', 'size': 'size', 'volume_id': 'volume-id'}
10917     _toPy = {'hardware-id': 'hardware_id', 'persistent': 'persistent', 'size': 'size', 'volume-id': 'volume_id'}
10918     def __init__(self, hardware_id=None, persistent=None, size=None, volume_id=None, **unknown_fields):
10919         '''
10920         hardware_id : str
10921         persistent : bool
10922         size : int
10923         volume_id : str
10924         '''
10925         self.hardware_id = hardware_id
10926         self.persistent = persistent
10927         self.size = size
10928         self.volume_id = volume_id
10929
10930
10931
10932 class VolumeParams(Type):
10933     _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume_tag': 'volume-tag'}
10934     _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume-tag': 'volume_tag'}
10935     def __init__(self, attachment=None, attributes=None, provider=None, size=None, tags=None, volume_tag=None, **unknown_fields):
10936         '''
10937         attachment : VolumeAttachmentParams
10938         attributes : typing.Mapping[str, typing.Any]
10939         provider : str
10940         size : int
10941         tags : typing.Mapping[str, str]
10942         volume_tag : str
10943         '''
10944         self.attachment = VolumeAttachmentParams.from_json(attachment) if attachment else None
10945         self.attributes = attributes
10946         self.provider = provider
10947         self.size = size
10948         self.tags = tags
10949         self.volume_tag = volume_tag
10950
10951
10952
10953 class VolumeParamsResult(Type):
10954     _toSchema = {'error': 'error', 'result': 'result'}
10955     _toPy = {'error': 'error', 'result': 'result'}
10956     def __init__(self, error=None, result=None, **unknown_fields):
10957         '''
10958         error : Error
10959         result : VolumeParams
10960         '''
10961         self.error = Error.from_json(error) if error else None
10962         self.result = VolumeParams.from_json(result) if result else None
10963
10964
10965
10966 class VolumeParamsResults(Type):
10967     _toSchema = {'results': 'results'}
10968     _toPy = {'results': 'results'}
10969     def __init__(self, results=None, **unknown_fields):
10970         '''
10971         results : typing.Sequence[~VolumeParamsResult]
10972         '''
10973         self.results = [VolumeParamsResult.from_json(o) for o in results or []]
10974
10975
10976
10977 class VolumeResult(Type):
10978     _toSchema = {'error': 'error', 'result': 'result'}
10979     _toPy = {'error': 'error', 'result': 'result'}
10980     def __init__(self, error=None, result=None, **unknown_fields):
10981         '''
10982         error : Error
10983         result : Volume
10984         '''
10985         self.error = Error.from_json(error) if error else None
10986         self.result = Volume.from_json(result) if result else None
10987
10988
10989
10990 class VolumeResults(Type):
10991     _toSchema = {'results': 'results'}
10992     _toPy = {'results': 'results'}
10993     def __init__(self, results=None, **unknown_fields):
10994         '''
10995         results : typing.Sequence[~VolumeResult]
10996         '''
10997         self.results = [VolumeResult.from_json(o) for o in results or []]
10998
10999
11000
11001 class Volumes(Type):
11002     _toSchema = {'volumes': 'volumes'}
11003     _toPy = {'volumes': 'volumes'}
11004     def __init__(self, volumes=None, **unknown_fields):
11005         '''
11006         volumes : typing.Sequence[~Volume]
11007         '''
11008         self.volumes = [Volume.from_json(o) for o in volumes or []]
11009
11010
11011
11012 class WatchContainer(Type):
11013     _toSchema = {'container_type': 'container-type', 'machine_tag': 'machine-tag'}
11014     _toPy = {'container-type': 'container_type', 'machine-tag': 'machine_tag'}
11015     def __init__(self, container_type=None, machine_tag=None, **unknown_fields):
11016         '''
11017         container_type : str
11018         machine_tag : str
11019         '''
11020         self.container_type = container_type
11021         self.machine_tag = machine_tag
11022
11023
11024
11025 class WatchContainers(Type):
11026     _toSchema = {'params': 'params'}
11027     _toPy = {'params': 'params'}
11028     def __init__(self, params=None, **unknown_fields):
11029         '''
11030         params : typing.Sequence[~WatchContainer]
11031         '''
11032         self.params = [WatchContainer.from_json(o) for o in params or []]
11033
11034
11035
11036 class ZoneResult(Type):
11037     _toSchema = {'available': 'available', 'error': 'error', 'name': 'name'}
11038     _toPy = {'available': 'available', 'error': 'error', 'name': 'name'}
11039     def __init__(self, available=None, error=None, name=None, **unknown_fields):
11040         '''
11041         available : bool
11042         error : Error
11043         name : str
11044         '''
11045         self.available = available
11046         self.error = Error.from_json(error) if error else None
11047         self.name = name
11048
11049
11050
11051 class ZoneResults(Type):
11052     _toSchema = {'results': 'results'}
11053     _toPy = {'results': 'results'}
11054     def __init__(self, results=None, **unknown_fields):
11055         '''
11056         results : typing.Sequence[~ZoneResult]
11057         '''
11058         self.results = [ZoneResult.from_json(o) for o in results or []]