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 Type, ReturnMapping
   5
   6
   7 class APIHostPortsResult(Type):
   8     _toSchema = {'servers': 'servers'}
   9     _toPy = {'servers': 'servers'}
  10     def __init__(self, servers=None):
  11         '''
  12         servers : typing.Sequence<+T_co>[~HostPort]<~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):
  22         '''
  23         name : str
  24         parameters : typing.Mapping<~KT, +VT_co>[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):
  39         '''
  40         action_tag : str
  41         message : str
  42         results : typing.Mapping<~KT, +VT_co>[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):
  56         '''
  57         results : typing.Sequence<+T_co>[~ActionExecutionResult]<~ActionExecutionResult>
  58         '''
  59         self.results = [ActionExecutionResult.from_json(o) for o in results or []]
  60
  61
  62
  63 class ActionResult(Type):
  64     _toSchema = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
  65     _toPy = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
  66     def __init__(self, action=None, completed=None, enqueued=None, error=None, message=None, output=None, started=None, status=None):
  67         '''
  68         action : Action
  69         completed : str
  70         enqueued : str
  71         error : Error
  72         message : str
  73         output : typing.Mapping<~KT, +VT_co>[str, typing.Any]
  74         started : str
  75         status : str
  76         '''
  77         self.action = Action.from_json(action) if action else None
  78         self.completed = completed
  79         self.enqueued = enqueued
  80         self.error = Error.from_json(error) if error else None
  81         self.message = message
  82         self.output = output
  83         self.started = started
  84         self.status = status
  85
  86
  87
  88 class ActionResults(Type):
  89     _toSchema = {'results': 'results'}
  90     _toPy = {'results': 'results'}
  91     def __init__(self, results=None):
  92         '''
  93         results : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
  94         '''
  95         self.results = [ActionResult.from_json(o) for o in results or []]
  96
  97
  98
  99 class ActionSpec(Type):
 100     _toSchema = {'description': 'description', 'params': 'params'}
 101     _toPy = {'description': 'description', 'params': 'params'}
 102     def __init__(self, description=None, params=None):
 103         '''
 104         description : str
 105         params : typing.Mapping<~KT, +VT_co>[str, typing.Any]
 106         '''
 107         self.description = description
 108         self.params = params
 109
 110
 111
 112 class Actions(Type):
 113     _toSchema = {'actions': 'actions'}
 114     _toPy = {'actions': 'actions'}
 115     def __init__(self, actions=None):
 116         '''
 117         actions : typing.Sequence<+T_co>[~Action]<~Action>
 118         '''
 119         self.actions = [Action.from_json(o) for o in actions or []]
 120
 121
 122
 123 class ActionsByName(Type):
 124     _toSchema = {'actions': 'actions', 'error': 'error', 'name': 'name'}
 125     _toPy = {'actions': 'actions', 'error': 'error', 'name': 'name'}
 126     def __init__(self, actions=None, error=None, name=None):
 127         '''
 128         actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
 129         error : Error
 130         name : str
 131         '''
 132         self.actions = [ActionResult.from_json(o) for o in actions or []]
 133         self.error = Error.from_json(error) if error else None
 134         self.name = name
 135
 136
 137
 138 class ActionsByNames(Type):
 139     _toSchema = {'actions': 'actions'}
 140     _toPy = {'actions': 'actions'}
 141     def __init__(self, actions=None):
 142         '''
 143         actions : typing.Sequence<+T_co>[~ActionsByName]<~ActionsByName>
 144         '''
 145         self.actions = [ActionsByName.from_json(o) for o in actions or []]
 146
 147
 148
 149 class ActionsByReceiver(Type):
 150     _toSchema = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
 151     _toPy = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
 152     def __init__(self, actions=None, error=None, receiver=None):
 153         '''
 154         actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
 155         error : Error
 156         receiver : str
 157         '''
 158         self.actions = [ActionResult.from_json(o) for o in actions or []]
 159         self.error = Error.from_json(error) if error else None
 160         self.receiver = receiver
 161
 162
 163
 164 class ActionsByReceivers(Type):
 165     _toSchema = {'actions': 'actions'}
 166     _toPy = {'actions': 'actions'}
 167     def __init__(self, actions=None):
 168         '''
 169         actions : typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
 170         '''
 171         self.actions = [ActionsByReceiver.from_json(o) for o in actions or []]
 172
 173
 174
 175 class AddApplicationUnits(Type):
 176     _toSchema = {'application': 'application', 'num_units': 'num-units', 'placement': 'placement'}
 177     _toPy = {'application': 'application', 'num-units': 'num_units', 'placement': 'placement'}
 178     def __init__(self, application=None, num_units=None, placement=None):
 179         '''
 180         application : str
 181         num_units : int
 182         placement : typing.Sequence<+T_co>[~Placement]<~Placement>
 183         '''
 184         self.application = application
 185         self.num_units = num_units
 186         self.placement = [Placement.from_json(o) for o in placement or []]
 187
 188
 189
 190 class AddApplicationUnitsResults(Type):
 191     _toSchema = {'units': 'units'}
 192     _toPy = {'units': 'units'}
 193     def __init__(self, units=None):
 194         '''
 195         units : typing.Sequence<+T_co>[str]
 196         '''
 197         self.units = units
 198
 199
 200
 201 class AddCharm(Type):
 202     _toSchema = {'channel': 'channel', 'url': 'url'}
 203     _toPy = {'channel': 'channel', 'url': 'url'}
 204     def __init__(self, channel=None, url=None):
 205         '''
 206         channel : str
 207         url : str
 208         '''
 209         self.channel = channel
 210         self.url = url
 211
 212
 213
 214 class AddCharmWithAuthorization(Type):
 215     _toSchema = {'channel': 'channel', 'macaroon': 'macaroon', 'url': 'url'}
 216     _toPy = {'channel': 'channel', 'macaroon': 'macaroon', 'url': 'url'}
 217     def __init__(self, channel=None, macaroon=None, url=None):
 218         '''
 219         channel : str
 220         macaroon : Macaroon
 221         url : str
 222         '''
 223         self.channel = channel
 224         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
 225         self.url = url
 226
 227
 228
 229 class AddMachineParams(Type):
 230     _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'}
 231     _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'}
 232     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):
 233         '''
 234         addresses : typing.Sequence<+T_co>[~Address]<~Address>
 235         constraints : Value
 236         container_type : str
 237         disks : typing.Sequence<+T_co>[~Constraints]<~Constraints>
 238         hardware_characteristics : HardwareCharacteristics
 239         instance_id : str
 240         jobs : typing.Sequence<+T_co>[str]
 241         nonce : str
 242         parent_id : str
 243         placement : Placement
 244         series : str
 245         '''
 246         self.addresses = [Address.from_json(o) for o in addresses or []]
 247         self.constraints = Value.from_json(constraints) if constraints else None
 248         self.container_type = container_type
 249         self.disks = [Constraints.from_json(o) for o in disks or []]
 250         self.hardware_characteristics = HardwareCharacteristics.from_json(hardware_characteristics) if hardware_characteristics else None
 251         self.instance_id = instance_id
 252         self.jobs = jobs
 253         self.nonce = nonce
 254         self.parent_id = parent_id
 255         self.placement = Placement.from_json(placement) if placement else None
 256         self.series = series
 257
 258
 259
 260 class AddMachines(Type):
 261     _toSchema = {'params': 'params'}
 262     _toPy = {'params': 'params'}
 263     def __init__(self, params=None):
 264         '''
 265         params : typing.Sequence<+T_co>[~AddMachineParams]<~AddMachineParams>
 266         '''
 267         self.params = [AddMachineParams.from_json(o) for o in params or []]
 268
 269
 270
 271 class AddMachinesResult(Type):
 272     _toSchema = {'error': 'error', 'machine': 'machine'}
 273     _toPy = {'error': 'error', 'machine': 'machine'}
 274     def __init__(self, error=None, machine=None):
 275         '''
 276         error : Error
 277         machine : str
 278         '''
 279         self.error = Error.from_json(error) if error else None
 280         self.machine = machine
 281
 282
 283
 284 class AddMachinesResults(Type):
 285     _toSchema = {'machines': 'machines'}
 286     _toPy = {'machines': 'machines'}
 287     def __init__(self, machines=None):
 288         '''
 289         machines : typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
 290         '''
 291         self.machines = [AddMachinesResult.from_json(o) for o in machines or []]
 292
 293
 294
 295 class AddPendingResourcesArgs(Type):
 296     _toSchema = {'addcharmwithauthorization': 'AddCharmWithAuthorization', 'entity': 'Entity', 'resources': 'Resources'}
 297     _toPy = {'AddCharmWithAuthorization': 'addcharmwithauthorization', 'Entity': 'entity', 'Resources': 'resources'}
 298     def __init__(self, addcharmwithauthorization=None, entity=None, resources=None):
 299         '''
 300         addcharmwithauthorization : AddCharmWithAuthorization
 301         entity : Entity
 302         resources : typing.Sequence<+T_co>[~CharmResource]<~CharmResource>
 303         '''
 304         self.addcharmwithauthorization = AddCharmWithAuthorization.from_json(addcharmwithauthorization) if addcharmwithauthorization else None
 305         self.entity = Entity.from_json(entity) if entity else None
 306         self.resources = [CharmResource.from_json(o) for o in resources or []]
 307
 308
 309
 310 class AddPendingResourcesResult(Type):
 311     _toSchema = {'errorresult': 'ErrorResult', 'pending_ids': 'pending-ids'}
 312     _toPy = {'ErrorResult': 'errorresult', 'pending-ids': 'pending_ids'}
 313     def __init__(self, errorresult=None, pending_ids=None):
 314         '''
 315         errorresult : ErrorResult
 316         pending_ids : typing.Sequence<+T_co>[str]
 317         '''
 318         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
 319         self.pending_ids = pending_ids
 320
 321
 322
 323 class AddRelation(Type):
 324     _toSchema = {'endpoints': 'endpoints'}
 325     _toPy = {'endpoints': 'endpoints'}
 326     def __init__(self, endpoints=None):
 327         '''
 328         endpoints : typing.Sequence<+T_co>[str]
 329         '''
 330         self.endpoints = endpoints
 331
 332
 333
 334 class AddRelationResults(Type):
 335     _toSchema = {'endpoints': 'endpoints'}
 336     _toPy = {'endpoints': 'endpoints'}
 337     def __init__(self, endpoints=None):
 338         '''
 339         endpoints : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
 340         '''
 341         self.endpoints = endpoints
 342
 343
 344
 345 class AddSubnetParams(Type):
 346     _toSchema = {'space_tag': 'space-tag', 'subnet_provider_id': 'subnet-provider-id', 'subnet_tag': 'subnet-tag', 'zones': 'zones'}
 347     _toPy = {'space-tag': 'space_tag', 'subnet-provider-id': 'subnet_provider_id', 'subnet-tag': 'subnet_tag', 'zones': 'zones'}
 348     def __init__(self, space_tag=None, subnet_provider_id=None, subnet_tag=None, zones=None):
 349         '''
 350         space_tag : str
 351         subnet_provider_id : str
 352         subnet_tag : str
 353         zones : typing.Sequence<+T_co>[str]
 354         '''
 355         self.space_tag = space_tag
 356         self.subnet_provider_id = subnet_provider_id
 357         self.subnet_tag = subnet_tag
 358         self.zones = zones
 359
 360
 361
 362 class AddSubnetsParams(Type):
 363     _toSchema = {'subnets': 'subnets'}
 364     _toPy = {'subnets': 'subnets'}
 365     def __init__(self, subnets=None):
 366         '''
 367         subnets : typing.Sequence<+T_co>[~AddSubnetParams]<~AddSubnetParams>
 368         '''
 369         self.subnets = [AddSubnetParams.from_json(o) for o in subnets or []]
 370
 371
 372
 373 class AddUser(Type):
 374     _toSchema = {'display_name': 'display-name', 'password': 'password', 'username': 'username'}
 375     _toPy = {'display-name': 'display_name', 'password': 'password', 'username': 'username'}
 376     def __init__(self, display_name=None, password=None, username=None):
 377         '''
 378         display_name : str
 379         password : str
 380         username : str
 381         '''
 382         self.display_name = display_name
 383         self.password = password
 384         self.username = username
 385
 386
 387
 388 class AddUserResult(Type):
 389     _toSchema = {'error': 'error', 'secret_key': 'secret-key', 'tag': 'tag'}
 390     _toPy = {'error': 'error', 'secret-key': 'secret_key', 'tag': 'tag'}
 391     def __init__(self, error=None, secret_key=None, tag=None):
 392         '''
 393         error : Error
 394         secret_key : typing.Sequence<+T_co>[int]
 395         tag : str
 396         '''
 397         self.error = Error.from_json(error) if error else None
 398         self.secret_key = secret_key
 399         self.tag = tag
 400
 401
 402
 403 class AddUserResults(Type):
 404     _toSchema = {'results': 'results'}
 405     _toPy = {'results': 'results'}
 406     def __init__(self, results=None):
 407         '''
 408         results : typing.Sequence<+T_co>[~AddUserResult]<~AddUserResult>
 409         '''
 410         self.results = [AddUserResult.from_json(o) for o in results or []]
 411
 412
 413
 414 class AddUsers(Type):
 415     _toSchema = {'users': 'users'}
 416     _toPy = {'users': 'users'}
 417     def __init__(self, users=None):
 418         '''
 419         users : typing.Sequence<+T_co>[~AddUser]<~AddUser>
 420         '''
 421         self.users = [AddUser.from_json(o) for o in users or []]
 422
 423
 424
 425 class Address(Type):
 426     _toSchema = {'scope': 'scope', 'space_name': 'space-name', 'type_': 'type', 'value': 'value'}
 427     _toPy = {'scope': 'scope', 'space-name': 'space_name', 'type': 'type_', 'value': 'value'}
 428     def __init__(self, scope=None, space_name=None, type_=None, value=None):
 429         '''
 430         scope : str
 431         space_name : str
 432         type_ : str
 433         value : str
 434         '''
 435         self.scope = scope
 436         self.space_name = space_name
 437         self.type_ = type_
 438         self.value = value
 439
 440
 441
 442 class AdoptResourcesArgs(Type):
 443     _toSchema = {'model_tag': 'model-tag', 'source_controller_version': 'source-controller-version'}
 444     _toPy = {'model-tag': 'model_tag', 'source-controller-version': 'source_controller_version'}
 445     def __init__(self, model_tag=None, source_controller_version=None):
 446         '''
 447         model_tag : str
 448         source_controller_version : Number
 449         '''
 450         self.model_tag = model_tag
 451         self.source_controller_version = Number.from_json(source_controller_version) if source_controller_version else None
 452
 453
 454
 455 class AgentGetEntitiesResult(Type):
 456     _toSchema = {'container_type': 'container-type', 'error': 'error', 'jobs': 'jobs', 'life': 'life'}
 457     _toPy = {'container-type': 'container_type', 'error': 'error', 'jobs': 'jobs', 'life': 'life'}
 458     def __init__(self, container_type=None, error=None, jobs=None, life=None):
 459         '''
 460         container_type : str
 461         error : Error
 462         jobs : typing.Sequence<+T_co>[str]
 463         life : str
 464         '''
 465         self.container_type = container_type
 466         self.error = Error.from_json(error) if error else None
 467         self.jobs = jobs
 468         self.life = life
 469
 470
 471
 472 class AgentGetEntitiesResults(Type):
 473     _toSchema = {'entities': 'entities'}
 474     _toPy = {'entities': 'entities'}
 475     def __init__(self, entities=None):
 476         '''
 477         entities : typing.Sequence<+T_co>[~AgentGetEntitiesResult]<~AgentGetEntitiesResult>
 478         '''
 479         self.entities = [AgentGetEntitiesResult.from_json(o) for o in entities or []]
 480
 481
 482
 483 class AgentVersionResult(Type):
 484     _toSchema = {'version': 'version'}
 485     _toPy = {'version': 'version'}
 486     def __init__(self, version=None):
 487         '''
 488         version : Number
 489         '''
 490         self.version = Number.from_json(version) if version else None
 491
 492
 493
 494 class AllWatcherId(Type):
 495     _toSchema = {'watcher_id': 'watcher-id'}
 496     _toPy = {'watcher-id': 'watcher_id'}
 497     def __init__(self, watcher_id=None):
 498         '''
 499         watcher_id : str
 500         '''
 501         self.watcher_id = watcher_id
 502
 503
 504
 505 class AllWatcherNextResults(Type):
 506     _toSchema = {'deltas': 'deltas'}
 507     _toPy = {'deltas': 'deltas'}
 508     def __init__(self, deltas=None):
 509         '''
 510         deltas : typing.Sequence<+T_co>[~Delta]<~Delta>
 511         '''
 512         self.deltas = [Delta.from_json(o) for o in deltas or []]
 513
 514
 515
 516 class AnnotationsGetResult(Type):
 517     _toSchema = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
 518     _toPy = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
 519     def __init__(self, annotations=None, entity=None, error=None):
 520         '''
 521         annotations : typing.Mapping<~KT, +VT_co>[str, str]
 522         entity : str
 523         error : ErrorResult
 524         '''
 525         self.annotations = annotations
 526         self.entity = entity
 527         self.error = ErrorResult.from_json(error) if error else None
 528
 529
 530
 531 class AnnotationsGetResults(Type):
 532     _toSchema = {'results': 'results'}
 533     _toPy = {'results': 'results'}
 534     def __init__(self, results=None):
 535         '''
 536         results : typing.Sequence<+T_co>[~AnnotationsGetResult]<~AnnotationsGetResult>
 537         '''
 538         self.results = [AnnotationsGetResult.from_json(o) for o in results or []]
 539
 540
 541
 542 class AnnotationsSet(Type):
 543     _toSchema = {'annotations': 'annotations'}
 544     _toPy = {'annotations': 'annotations'}
 545     def __init__(self, annotations=None):
 546         '''
 547         annotations : typing.Sequence<+T_co>[~EntityAnnotations]<~EntityAnnotations>
 548         '''
 549         self.annotations = [EntityAnnotations.from_json(o) for o in annotations or []]
 550
 551
 552
 553 class ApplicationCharmActionsResult(Type):
 554     _toSchema = {'actions': 'actions', 'application_tag': 'application-tag', 'error': 'error'}
 555     _toPy = {'actions': 'actions', 'application-tag': 'application_tag', 'error': 'error'}
 556     def __init__(self, actions=None, application_tag=None, error=None):
 557         '''
 558         actions : typing.Mapping<~KT, +VT_co>[str, ~ActionSpec]<~ActionSpec>
 559         application_tag : str
 560         error : Error
 561         '''
 562         self.actions = actions
 563         self.application_tag = application_tag
 564         self.error = Error.from_json(error) if error else None
 565
 566
 567
 568 class ApplicationCharmRelations(Type):
 569     _toSchema = {'application': 'application'}
 570     _toPy = {'application': 'application'}
 571     def __init__(self, application=None):
 572         '''
 573         application : str
 574         '''
 575         self.application = application
 576
 577
 578
 579 class ApplicationCharmRelationsResults(Type):
 580     _toSchema = {'charm_relations': 'charm-relations'}
 581     _toPy = {'charm-relations': 'charm_relations'}
 582     def __init__(self, charm_relations=None):
 583         '''
 584         charm_relations : typing.Sequence<+T_co>[str]
 585         '''
 586         self.charm_relations = charm_relations
 587
 588
 589
 590 class ApplicationDeploy(Type):
 591     _toSchema = {'application': 'application', 'channel': 'channel', 'charm_url': 'charm-url', 'config': 'config', 'config_yaml': 'config-yaml', 'constraints': 'constraints', 'endpoint_bindings': 'endpoint-bindings', 'num_units': 'num-units', 'placement': 'placement', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
 592     _toPy = {'application': 'application', 'channel': 'channel', 'charm-url': 'charm_url', 'config': 'config', 'config-yaml': 'config_yaml', 'constraints': 'constraints', 'endpoint-bindings': 'endpoint_bindings', 'num-units': 'num_units', 'placement': 'placement', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
 593     def __init__(self, application=None, channel=None, charm_url=None, config=None, config_yaml=None, constraints=None, endpoint_bindings=None, num_units=None, placement=None, resources=None, series=None, storage=None):
 594         '''
 595         application : str
 596         channel : str
 597         charm_url : str
 598         config : typing.Mapping<~KT, +VT_co>[str, str]
 599         config_yaml : str
 600         constraints : Value
 601         endpoint_bindings : typing.Mapping<~KT, +VT_co>[str, str]
 602         num_units : int
 603         placement : typing.Sequence<+T_co>[~Placement]<~Placement>
 604         resources : typing.Mapping<~KT, +VT_co>[str, str]
 605         series : str
 606         storage : typing.Mapping<~KT, +VT_co>[str, ~Constraints]<~Constraints>
 607         '''
 608         self.application = application
 609         self.channel = channel
 610         self.charm_url = charm_url
 611         self.config = config
 612         self.config_yaml = config_yaml
 613         self.constraints = Value.from_json(constraints) if constraints else None
 614         self.endpoint_bindings = endpoint_bindings
 615         self.num_units = num_units
 616         self.placement = [Placement.from_json(o) for o in placement or []]
 617         self.resources = resources
 618         self.series = series
 619         self.storage = storage
 620
 621
 622
 623 class ApplicationDestroy(Type):
 624     _toSchema = {'application': 'application'}
 625     _toPy = {'application': 'application'}
 626     def __init__(self, application=None):
 627         '''
 628         application : str
 629         '''
 630         self.application = application
 631
 632
 633
 634 class ApplicationExpose(Type):
 635     _toSchema = {'application': 'application'}
 636     _toPy = {'application': 'application'}
 637     def __init__(self, application=None):
 638         '''
 639         application : str
 640         '''
 641         self.application = application
 642
 643
 644
 645 class ApplicationGet(Type):
 646     _toSchema = {'application': 'application'}
 647     _toPy = {'application': 'application'}
 648     def __init__(self, application=None):
 649         '''
 650         application : str
 651         '''
 652         self.application = application
 653
 654
 655
 656 class ApplicationGetResults(Type):
 657     _toSchema = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
 658     _toPy = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
 659     def __init__(self, application=None, charm=None, config=None, constraints=None, series=None):
 660         '''
 661         application : str
 662         charm : str
 663         config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
 664         constraints : Value
 665         series : str
 666         '''
 667         self.application = application
 668         self.charm = charm
 669         self.config = config
 670         self.constraints = Value.from_json(constraints) if constraints else None
 671         self.series = series
 672
 673
 674
 675 class ApplicationMetricCredential(Type):
 676     _toSchema = {'application': 'application', 'metrics_credentials': 'metrics-credentials'}
 677     _toPy = {'application': 'application', 'metrics-credentials': 'metrics_credentials'}
 678     def __init__(self, application=None, metrics_credentials=None):
 679         '''
 680         application : str
 681         metrics_credentials : typing.Sequence<+T_co>[int]
 682         '''
 683         self.application = application
 684         self.metrics_credentials = metrics_credentials
 685
 686
 687
 688 class ApplicationMetricCredentials(Type):
 689     _toSchema = {'creds': 'creds'}
 690     _toPy = {'creds': 'creds'}
 691     def __init__(self, creds=None):
 692         '''
 693         creds : typing.Sequence<+T_co>[~ApplicationMetricCredential]<~ApplicationMetricCredential>
 694         '''
 695         self.creds = [ApplicationMetricCredential.from_json(o) for o in creds or []]
 696
 697
 698
 699 class ApplicationRelationsChange(Type):
 700     _toSchema = {'changed': 'changed', 'removed': 'removed'}
 701     _toPy = {'changed': 'changed', 'removed': 'removed'}
 702     def __init__(self, changed=None, removed=None):
 703         '''
 704         changed : typing.Sequence<+T_co>[~RelationChange]<~RelationChange>
 705         removed : typing.Sequence<+T_co>[int]
 706         '''
 707         self.changed = [RelationChange.from_json(o) for o in changed or []]
 708         self.removed = removed
 709
 710
 711
 712 class ApplicationRelationsWatchResult(Type):
 713     _toSchema = {'applicationrelationswatcherid': 'ApplicationRelationsWatcherId', 'changes': 'changes', 'error': 'error'}
 714     _toPy = {'ApplicationRelationsWatcherId': 'applicationrelationswatcherid', 'changes': 'changes', 'error': 'error'}
 715     def __init__(self, applicationrelationswatcherid=None, changes=None, error=None):
 716         '''
 717         applicationrelationswatcherid : str
 718         changes : ApplicationRelationsChange
 719         error : Error
 720         '''
 721         self.applicationrelationswatcherid = applicationrelationswatcherid
 722         self.changes = ApplicationRelationsChange.from_json(changes) if changes else None
 723         self.error = Error.from_json(error) if error else None
 724
 725
 726
 727 class ApplicationSet(Type):
 728     _toSchema = {'application': 'application', 'options': 'options'}
 729     _toPy = {'application': 'application', 'options': 'options'}
 730     def __init__(self, application=None, options=None):
 731         '''
 732         application : str
 733         options : typing.Mapping<~KT, +VT_co>[str, str]
 734         '''
 735         self.application = application
 736         self.options = options
 737
 738
 739
 740 class ApplicationSetCharm(Type):
 741     _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'}
 742     _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'}
 743     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):
 744         '''
 745         application : str
 746         channel : str
 747         charm_url : str
 748         config_settings : typing.Mapping<~KT, +VT_co>[str, str]
 749         config_settings_yaml : str
 750         force_series : bool
 751         force_units : bool
 752         resource_ids : typing.Mapping<~KT, +VT_co>[str, str]
 753         storage_constraints : typing.Mapping<~KT, +VT_co>[str, ~StorageConstraints]<~StorageConstraints>
 754         '''
 755         self.application = application
 756         self.channel = channel
 757         self.charm_url = charm_url
 758         self.config_settings = config_settings
 759         self.config_settings_yaml = config_settings_yaml
 760         self.force_series = force_series
 761         self.force_units = force_units
 762         self.resource_ids = resource_ids
 763         self.storage_constraints = storage_constraints
 764
 765
 766
 767 class ApplicationStatus(Type):
 768     _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'}
 769     _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'}
 770     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):
 771         '''
 772         can_upgrade_to : str
 773         charm : str
 774         err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
 775         exposed : bool
 776         life : str
 777         meter_statuses : typing.Mapping<~KT, +VT_co>[str, ~MeterStatus]<~MeterStatus>
 778         relations : typing.Sequence<+T_co>[str]
 779         series : str
 780         status : DetailedStatus
 781         subordinate_to : typing.Sequence<+T_co>[str]
 782         units : typing.Mapping<~KT, +VT_co>[str, ~UnitStatus]<~UnitStatus>
 783         workload_version : str
 784         '''
 785         self.can_upgrade_to = can_upgrade_to
 786         self.charm = charm
 787         self.err = err
 788         self.exposed = exposed
 789         self.life = life
 790         self.meter_statuses = meter_statuses
 791         self.relations = relations
 792         self.series = series
 793         self.status = DetailedStatus.from_json(status) if status else None
 794         self.subordinate_to = subordinate_to
 795         self.units = units
 796         self.workload_version = workload_version
 797
 798
 799
 800 class ApplicationStatusResult(Type):
 801     _toSchema = {'application': 'application', 'error': 'error', 'units': 'units'}
 802     _toPy = {'application': 'application', 'error': 'error', 'units': 'units'}
 803     def __init__(self, application=None, error=None, units=None):
 804         '''
 805         application : StatusResult
 806         error : Error
 807         units : typing.Mapping<~KT, +VT_co>[str, ~StatusResult]<~StatusResult>
 808         '''
 809         self.application = StatusResult.from_json(application) if application else None
 810         self.error = Error.from_json(error) if error else None
 811         self.units = units
 812
 813
 814
 815 class ApplicationStatusResults(Type):
 816     _toSchema = {'results': 'results'}
 817     _toPy = {'results': 'results'}
 818     def __init__(self, results=None):
 819         '''
 820         results : typing.Sequence<+T_co>[~ApplicationStatusResult]<~ApplicationStatusResult>
 821         '''
 822         self.results = [ApplicationStatusResult.from_json(o) for o in results or []]
 823
 824
 825
 826 class ApplicationTag(Type):
 827     _toSchema = {'name': 'Name'}
 828     _toPy = {'Name': 'name'}
 829     def __init__(self, name=None):
 830         '''
 831         name : str
 832         '''
 833         self.name = name
 834
 835
 836
 837 class ApplicationURLs(Type):
 838     _toSchema = {'application_urls': 'application-urls'}
 839     _toPy = {'application-urls': 'application_urls'}
 840     def __init__(self, application_urls=None):
 841         '''
 842         application_urls : typing.Sequence<+T_co>[str]
 843         '''
 844         self.application_urls = application_urls
 845
 846
 847
 848 class ApplicationUnexpose(Type):
 849     _toSchema = {'application': 'application'}
 850     _toPy = {'application': 'application'}
 851     def __init__(self, application=None):
 852         '''
 853         application : str
 854         '''
 855         self.application = application
 856
 857
 858
 859 class ApplicationUnset(Type):
 860     _toSchema = {'application': 'application', 'options': 'options'}
 861     _toPy = {'application': 'application', 'options': 'options'}
 862     def __init__(self, application=None, options=None):
 863         '''
 864         application : str
 865         options : typing.Sequence<+T_co>[str]
 866         '''
 867         self.application = application
 868         self.options = options
 869
 870
 871
 872 class ApplicationUpdate(Type):
 873     _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'}
 874     _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'}
 875     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):
 876         '''
 877         application : str
 878         charm_url : str
 879         constraints : Value
 880         force_charm_url : bool
 881         force_series : bool
 882         min_units : int
 883         settings : typing.Mapping<~KT, +VT_co>[str, str]
 884         settings_yaml : str
 885         '''
 886         self.application = application
 887         self.charm_url = charm_url
 888         self.constraints = Value.from_json(constraints) if constraints else None
 889         self.force_charm_url = force_charm_url
 890         self.force_series = force_series
 891         self.min_units = min_units
 892         self.settings = settings
 893         self.settings_yaml = settings_yaml
 894
 895
 896
 897 class ApplicationsCharmActionsResults(Type):
 898     _toSchema = {'results': 'results'}
 899     _toPy = {'results': 'results'}
 900     def __init__(self, results=None):
 901         '''
 902         results : typing.Sequence<+T_co>[~ApplicationCharmActionsResult]<~ApplicationCharmActionsResult>
 903         '''
 904         self.results = [ApplicationCharmActionsResult.from_json(o) for o in results or []]
 905
 906
 907
 908 class ApplicationsDeploy(Type):
 909     _toSchema = {'applications': 'applications'}
 910     _toPy = {'applications': 'applications'}
 911     def __init__(self, applications=None):
 912         '''
 913         applications : typing.Sequence<+T_co>[~ApplicationDeploy]<~ApplicationDeploy>
 914         '''
 915         self.applications = [ApplicationDeploy.from_json(o) for o in applications or []]
 916
 917
 918
 919 class BackupsCreateArgs(Type):
 920     _toSchema = {'notes': 'notes'}
 921     _toPy = {'notes': 'notes'}
 922     def __init__(self, notes=None):
 923         '''
 924         notes : str
 925         '''
 926         self.notes = notes
 927
 928
 929
 930 class BackupsInfoArgs(Type):
 931     _toSchema = {'id_': 'id'}
 932     _toPy = {'id': 'id_'}
 933     def __init__(self, id_=None):
 934         '''
 935         id_ : str
 936         '''
 937         self.id_ = id_
 938
 939
 940
 941 class BackupsListArgs(Type):
 942     _toSchema = {}
 943     _toPy = {}
 944     def __init__(self):
 945         '''
 946
 947         '''
 948         pass
 949
 950
 951
 952 class BackupsListResult(Type):
 953     _toSchema = {'list_': 'list'}
 954     _toPy = {'list': 'list_'}
 955     def __init__(self, list_=None):
 956         '''
 957         list_ : typing.Sequence<+T_co>[~BackupsMetadataResult]<~BackupsMetadataResult>
 958         '''
 959         self.list_ = [BackupsMetadataResult.from_json(o) for o in list_ or []]
 960
 961
 962
 963 class BackupsMetadataResult(Type):
 964     _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'}
 965     _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'}
 966     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):
 967         '''
 968         ca_cert : str
 969         ca_private_key : str
 970         checksum : str
 971         checksum_format : str
 972         finished : str
 973         hostname : str
 974         id_ : str
 975         machine : str
 976         model : str
 977         notes : str
 978         series : str
 979         size : int
 980         started : str
 981         stored : str
 982         version : Number
 983         '''
 984         self.ca_cert = ca_cert
 985         self.ca_private_key = ca_private_key
 986         self.checksum = checksum
 987         self.checksum_format = checksum_format
 988         self.finished = finished
 989         self.hostname = hostname
 990         self.id_ = id_
 991         self.machine = machine
 992         self.model = model
 993         self.notes = notes
 994         self.series = series
 995         self.size = size
 996         self.started = started
 997         self.stored = stored
 998         self.version = Number.from_json(version) if version else None
 999
1000
1001
1002 class BackupsRemoveArgs(Type):
1003     _toSchema = {'id_': 'id'}
1004     _toPy = {'id': 'id_'}
1005     def __init__(self, id_=None):
1006         '''
1007         id_ : str
1008         '''
1009         self.id_ = id_
1010
1011
1012
1013 class Binary(Type):
1014     _toSchema = {'arch': 'Arch', 'number': 'Number', 'series': 'Series'}
1015     _toPy = {'Arch': 'arch', 'Number': 'number', 'Series': 'series'}
1016     def __init__(self, arch=None, number=None, series=None):
1017         '''
1018         arch : str
1019         number : Number
1020         series : str
1021         '''
1022         self.arch = arch
1023         self.number = Number.from_json(number) if number else None
1024         self.series = series
1025
1026
1027
1028 class Block(Type):
1029     _toSchema = {'id_': 'id', 'message': 'message', 'tag': 'tag', 'type_': 'type'}
1030     _toPy = {'id': 'id_', 'message': 'message', 'tag': 'tag', 'type': 'type_'}
1031     def __init__(self, id_=None, message=None, tag=None, type_=None):
1032         '''
1033         id_ : str
1034         message : str
1035         tag : str
1036         type_ : str
1037         '''
1038         self.id_ = id_
1039         self.message = message
1040         self.tag = tag
1041         self.type_ = type_
1042
1043
1044
1045 class BlockDevice(Type):
1046     _toSchema = {'busaddress': 'BusAddress', 'devicelinks': 'DeviceLinks', 'devicename': 'DeviceName', 'filesystemtype': 'FilesystemType', 'hardwareid': 'HardwareId', 'inuse': 'InUse', 'label': 'Label', 'mountpoint': 'MountPoint', 'size': 'Size', 'uuid': 'UUID'}
1047     _toPy = {'BusAddress': 'busaddress', 'DeviceLinks': 'devicelinks', 'DeviceName': 'devicename', 'FilesystemType': 'filesystemtype', 'HardwareId': 'hardwareid', 'InUse': 'inuse', 'Label': 'label', 'MountPoint': 'mountpoint', 'Size': 'size', 'UUID': 'uuid'}
1048     def __init__(self, busaddress=None, devicelinks=None, devicename=None, filesystemtype=None, hardwareid=None, inuse=None, label=None, mountpoint=None, size=None, uuid=None):
1049         '''
1050         busaddress : str
1051         devicelinks : typing.Sequence<+T_co>[str]
1052         devicename : str
1053         filesystemtype : str
1054         hardwareid : str
1055         inuse : bool
1056         label : str
1057         mountpoint : str
1058         size : int
1059         uuid : str
1060         '''
1061         self.busaddress = busaddress
1062         self.devicelinks = devicelinks
1063         self.devicename = devicename
1064         self.filesystemtype = filesystemtype
1065         self.hardwareid = hardwareid
1066         self.inuse = inuse
1067         self.label = label
1068         self.mountpoint = mountpoint
1069         self.size = size
1070         self.uuid = uuid
1071
1072
1073
1074 class BlockDeviceResult(Type):
1075     _toSchema = {'error': 'error', 'result': 'result'}
1076     _toPy = {'error': 'error', 'result': 'result'}
1077     def __init__(self, error=None, result=None):
1078         '''
1079         error : Error
1080         result : BlockDevice
1081         '''
1082         self.error = Error.from_json(error) if error else None
1083         self.result = BlockDevice.from_json(result) if result else None
1084
1085
1086
1087 class BlockDeviceResults(Type):
1088     _toSchema = {'results': 'results'}
1089     _toPy = {'results': 'results'}
1090     def __init__(self, results=None):
1091         '''
1092         results : typing.Sequence<+T_co>[~BlockDeviceResult]<~BlockDeviceResult>
1093         '''
1094         self.results = [BlockDeviceResult.from_json(o) for o in results or []]
1095
1096
1097
1098 class BlockResult(Type):
1099     _toSchema = {'error': 'error', 'result': 'result'}
1100     _toPy = {'error': 'error', 'result': 'result'}
1101     def __init__(self, error=None, result=None):
1102         '''
1103         error : Error
1104         result : Block
1105         '''
1106         self.error = Error.from_json(error) if error else None
1107         self.result = Block.from_json(result) if result else None
1108
1109
1110
1111 class BlockResults(Type):
1112     _toSchema = {'results': 'results'}
1113     _toPy = {'results': 'results'}
1114     def __init__(self, results=None):
1115         '''
1116         results : typing.Sequence<+T_co>[~BlockResult]<~BlockResult>
1117         '''
1118         self.results = [BlockResult.from_json(o) for o in results or []]
1119
1120
1121
1122 class BlockSwitchParams(Type):
1123     _toSchema = {'message': 'message', 'type_': 'type'}
1124     _toPy = {'message': 'message', 'type': 'type_'}
1125     def __init__(self, message=None, type_=None):
1126         '''
1127         message : str
1128         type_ : str
1129         '''
1130         self.message = message
1131         self.type_ = type_
1132
1133
1134
1135 class BoolResult(Type):
1136     _toSchema = {'error': 'error', 'result': 'result'}
1137     _toPy = {'error': 'error', 'result': 'result'}
1138     def __init__(self, error=None, result=None):
1139         '''
1140         error : Error
1141         result : bool
1142         '''
1143         self.error = Error.from_json(error) if error else None
1144         self.result = result
1145
1146
1147
1148 class BoolResults(Type):
1149     _toSchema = {'results': 'results'}
1150     _toPy = {'results': 'results'}
1151     def __init__(self, results=None):
1152         '''
1153         results : typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
1154         '''
1155         self.results = [BoolResult.from_json(o) for o in results or []]
1156
1157
1158
1159 class BundleChange(Type):
1160     _toSchema = {'args': 'args', 'id_': 'id', 'method': 'method', 'requires': 'requires'}
1161     _toPy = {'args': 'args', 'id': 'id_', 'method': 'method', 'requires': 'requires'}
1162     def __init__(self, args=None, id_=None, method=None, requires=None):
1163         '''
1164         args : typing.Sequence<+T_co>[typing.Any]
1165         id_ : str
1166         method : str
1167         requires : typing.Sequence<+T_co>[str]
1168         '''
1169         self.args = args
1170         self.id_ = id_
1171         self.method = method
1172         self.requires = requires
1173
1174
1175
1176 class BundleChangesParams(Type):
1177     _toSchema = {'yaml': 'yaml'}
1178     _toPy = {'yaml': 'yaml'}
1179     def __init__(self, yaml=None):
1180         '''
1181         yaml : str
1182         '''
1183         self.yaml = yaml
1184
1185
1186
1187 class BundleChangesResults(Type):
1188     _toSchema = {'changes': 'changes', 'errors': 'errors'}
1189     _toPy = {'changes': 'changes', 'errors': 'errors'}
1190     def __init__(self, changes=None, errors=None):
1191         '''
1192         changes : typing.Sequence<+T_co>[~BundleChange]<~BundleChange>
1193         errors : typing.Sequence<+T_co>[str]
1194         '''
1195         self.changes = [BundleChange.from_json(o) for o in changes or []]
1196         self.errors = errors
1197
1198
1199
1200 class BytesResult(Type):
1201     _toSchema = {'result': 'result'}
1202     _toPy = {'result': 'result'}
1203     def __init__(self, result=None):
1204         '''
1205         result : typing.Sequence<+T_co>[int]
1206         '''
1207         self.result = result
1208
1209
1210
1211 class CharmActionSpec(Type):
1212     _toSchema = {'description': 'description', 'params': 'params'}
1213     _toPy = {'description': 'description', 'params': 'params'}
1214     def __init__(self, description=None, params=None):
1215         '''
1216         description : str
1217         params : typing.Mapping<~KT, +VT_co>[str, typing.Any]
1218         '''
1219         self.description = description
1220         self.params = params
1221
1222
1223
1224 class CharmActions(Type):
1225     _toSchema = {'specs': 'specs'}
1226     _toPy = {'specs': 'specs'}
1227     def __init__(self, specs=None):
1228         '''
1229         specs : typing.Mapping<~KT, +VT_co>[str, ~CharmActionSpec]<~CharmActionSpec>
1230         '''
1231         self.specs = specs
1232
1233
1234
1235 class CharmInfo(Type):
1236     _toSchema = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
1237     _toPy = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
1238     def __init__(self, actions=None, config=None, meta=None, metrics=None, revision=None, url=None):
1239         '''
1240         actions : CharmActions
1241         config : typing.Mapping<~KT, +VT_co>[str, ~CharmOption]<~CharmOption>
1242         meta : CharmMeta
1243         metrics : CharmMetrics
1244         revision : int
1245         url : str
1246         '''
1247         self.actions = CharmActions.from_json(actions) if actions else None
1248         self.config = config
1249         self.meta = CharmMeta.from_json(meta) if meta else None
1250         self.metrics = CharmMetrics.from_json(metrics) if metrics else None
1251         self.revision = revision
1252         self.url = url
1253
1254
1255
1256 class CharmMeta(Type):
1257     _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'}
1258     _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'}
1259     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):
1260         '''
1261         categories : typing.Sequence<+T_co>[str]
1262         description : str
1263         extra_bindings : typing.Mapping<~KT, +VT_co>[str, str]
1264         min_juju_version : str
1265         name : str
1266         payload_classes : typing.Mapping<~KT, +VT_co>[str, ~CharmPayloadClass]<~CharmPayloadClass>
1267         peers : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
1268         provides : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
1269         requires : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
1270         resources : typing.Mapping<~KT, +VT_co>[str, ~CharmResourceMeta]<~CharmResourceMeta>
1271         series : typing.Sequence<+T_co>[str]
1272         storage : typing.Mapping<~KT, +VT_co>[str, ~CharmStorage]<~CharmStorage>
1273         subordinate : bool
1274         summary : str
1275         tags : typing.Sequence<+T_co>[str]
1276         terms : typing.Sequence<+T_co>[str]
1277         '''
1278         self.categories = categories
1279         self.description = description
1280         self.extra_bindings = extra_bindings
1281         self.min_juju_version = min_juju_version
1282         self.name = name
1283         self.payload_classes = payload_classes
1284         self.peers = peers
1285         self.provides = provides
1286         self.requires = requires
1287         self.resources = resources
1288         self.series = series
1289         self.storage = storage
1290         self.subordinate = subordinate
1291         self.summary = summary
1292         self.tags = tags
1293         self.terms = terms
1294
1295
1296
1297 class CharmMetric(Type):
1298     _toSchema = {'description': 'description', 'type_': 'type'}
1299     _toPy = {'description': 'description', 'type': 'type_'}
1300     def __init__(self, description=None, type_=None):
1301         '''
1302         description : str
1303         type_ : str
1304         '''
1305         self.description = description
1306         self.type_ = type_
1307
1308
1309
1310 class CharmMetrics(Type):
1311     _toSchema = {'metrics': 'metrics', 'plan': 'plan'}
1312     _toPy = {'metrics': 'metrics', 'plan': 'plan'}
1313     def __init__(self, metrics=None, plan=None):
1314         '''
1315         metrics : typing.Mapping<~KT, +VT_co>[str, ~CharmMetric]<~CharmMetric>
1316         plan : CharmPlan
1317         '''
1318         self.metrics = metrics
1319         self.plan = CharmPlan.from_json(plan) if plan else None
1320
1321
1322
1323 class CharmOption(Type):
1324     _toSchema = {'default': 'default', 'description': 'description', 'type_': 'type'}
1325     _toPy = {'default': 'default', 'description': 'description', 'type': 'type_'}
1326     def __init__(self, default=None, description=None, type_=None):
1327         '''
1328         default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
1329         description : str
1330         type_ : str
1331         '''
1332         self.default = default
1333         self.description = description
1334         self.type_ = type_
1335
1336
1337
1338 class CharmPayloadClass(Type):
1339     _toSchema = {'name': 'name', 'type_': 'type'}
1340     _toPy = {'name': 'name', 'type': 'type_'}
1341     def __init__(self, name=None, type_=None):
1342         '''
1343         name : str
1344         type_ : str
1345         '''
1346         self.name = name
1347         self.type_ = type_
1348
1349
1350
1351 class CharmPlan(Type):
1352     _toSchema = {'required': 'required'}
1353     _toPy = {'required': 'required'}
1354     def __init__(self, required=None):
1355         '''
1356         required : bool
1357         '''
1358         self.required = required
1359
1360
1361
1362 class CharmRelation(Type):
1363     _toSchema = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'optional': 'optional', 'role': 'role', 'scope': 'scope'}
1364     _toPy = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'optional': 'optional', 'role': 'role', 'scope': 'scope'}
1365     def __init__(self, interface=None, limit=None, name=None, optional=None, role=None, scope=None):
1366         '''
1367         interface : str
1368         limit : int
1369         name : str
1370         optional : bool
1371         role : str
1372         scope : str
1373         '''
1374         self.interface = interface
1375         self.limit = limit
1376         self.name = name
1377         self.optional = optional
1378         self.role = role
1379         self.scope = scope
1380
1381
1382
1383 class CharmResource(Type):
1384     _toSchema = {'description': 'description', 'fingerprint': 'fingerprint', 'name': 'name', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'type_': 'type'}
1385     _toPy = {'description': 'description', 'fingerprint': 'fingerprint', 'name': 'name', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'type': 'type_'}
1386     def __init__(self, description=None, fingerprint=None, name=None, origin=None, path=None, revision=None, size=None, type_=None):
1387         '''
1388         description : str
1389         fingerprint : typing.Sequence<+T_co>[int]
1390         name : str
1391         origin : str
1392         path : str
1393         revision : int
1394         size : int
1395         type_ : str
1396         '''
1397         self.description = description
1398         self.fingerprint = fingerprint
1399         self.name = name
1400         self.origin = origin
1401         self.path = path
1402         self.revision = revision
1403         self.size = size
1404         self.type_ = type_
1405
1406
1407
1408 class CharmResourceMeta(Type):
1409     _toSchema = {'description': 'description', 'name': 'name', 'path': 'path', 'type_': 'type'}
1410     _toPy = {'description': 'description', 'name': 'name', 'path': 'path', 'type': 'type_'}
1411     def __init__(self, description=None, name=None, path=None, type_=None):
1412         '''
1413         description : str
1414         name : str
1415         path : str
1416         type_ : str
1417         '''
1418         self.description = description
1419         self.name = name
1420         self.path = path
1421         self.type_ = type_
1422
1423
1424
1425 class CharmStorage(Type):
1426     _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'}
1427     _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_'}
1428     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):
1429         '''
1430         count_max : int
1431         count_min : int
1432         description : str
1433         location : str
1434         minimum_size : int
1435         name : str
1436         properties : typing.Sequence<+T_co>[str]
1437         read_only : bool
1438         shared : bool
1439         type_ : str
1440         '''
1441         self.count_max = count_max
1442         self.count_min = count_min
1443         self.description = description
1444         self.location = location
1445         self.minimum_size = minimum_size
1446         self.name = name
1447         self.properties = properties
1448         self.read_only = read_only
1449         self.shared = shared
1450         self.type_ = type_
1451
1452
1453
1454 class CharmURL(Type):
1455     _toSchema = {'url': 'url'}
1456     _toPy = {'url': 'url'}
1457     def __init__(self, url=None):
1458         '''
1459         url : str
1460         '''
1461         self.url = url
1462
1463
1464
1465 class CharmURLs(Type):
1466     _toSchema = {'urls': 'urls'}
1467     _toPy = {'urls': 'urls'}
1468     def __init__(self, urls=None):
1469         '''
1470         urls : typing.Sequence<+T_co>[~CharmURL]<~CharmURL>
1471         '''
1472         self.urls = [CharmURL.from_json(o) for o in urls or []]
1473
1474
1475
1476 class CharmsList(Type):
1477     _toSchema = {'names': 'names'}
1478     _toPy = {'names': 'names'}
1479     def __init__(self, names=None):
1480         '''
1481         names : typing.Sequence<+T_co>[str]
1482         '''
1483         self.names = names
1484
1485
1486
1487 class CharmsListResult(Type):
1488     _toSchema = {'charm_urls': 'charm-urls'}
1489     _toPy = {'charm-urls': 'charm_urls'}
1490     def __init__(self, charm_urls=None):
1491         '''
1492         charm_urls : typing.Sequence<+T_co>[str]
1493         '''
1494         self.charm_urls = charm_urls
1495
1496
1497
1498 class ClaimLeadershipBulkParams(Type):
1499     _toSchema = {'params': 'params'}
1500     _toPy = {'params': 'params'}
1501     def __init__(self, params=None):
1502         '''
1503         params : typing.Sequence<+T_co>[~ClaimLeadershipParams]<~ClaimLeadershipParams>
1504         '''
1505         self.params = [ClaimLeadershipParams.from_json(o) for o in params or []]
1506
1507
1508
1509 class ClaimLeadershipBulkResults(Type):
1510     _toSchema = {'results': 'results'}
1511     _toPy = {'results': 'results'}
1512     def __init__(self, results=None):
1513         '''
1514         results : typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
1515         '''
1516         self.results = [ErrorResult.from_json(o) for o in results or []]
1517
1518
1519
1520 class ClaimLeadershipParams(Type):
1521     _toSchema = {'application_tag': 'application-tag', 'duration': 'duration', 'unit_tag': 'unit-tag'}
1522     _toPy = {'application-tag': 'application_tag', 'duration': 'duration', 'unit-tag': 'unit_tag'}
1523     def __init__(self, application_tag=None, duration=None, unit_tag=None):
1524         '''
1525         application_tag : str
1526         duration : float
1527         unit_tag : str
1528         '''
1529         self.application_tag = application_tag
1530         self.duration = duration
1531         self.unit_tag = unit_tag
1532
1533
1534
1535 class Cloud(Type):
1536     _toSchema = {'auth_types': 'auth-types', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'regions': 'regions', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
1537     _toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
1538     def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None):
1539         '''
1540         auth_types : typing.Sequence<+T_co>[str]
1541         endpoint : str
1542         identity_endpoint : str
1543         regions : typing.Sequence<+T_co>[~CloudRegion]<~CloudRegion>
1544         storage_endpoint : str
1545         type_ : str
1546         '''
1547         self.auth_types = auth_types
1548         self.endpoint = endpoint
1549         self.identity_endpoint = identity_endpoint
1550         self.regions = [CloudRegion.from_json(o) for o in regions or []]
1551         self.storage_endpoint = storage_endpoint
1552         self.type_ = type_
1553
1554
1555
1556 class CloudCredential(Type):
1557     _toSchema = {'attrs': 'attrs', 'auth_type': 'auth-type', 'redacted': 'redacted'}
1558     _toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'redacted': 'redacted'}
1559     def __init__(self, attrs=None, auth_type=None, redacted=None):
1560         '''
1561         attrs : typing.Mapping<~KT, +VT_co>[str, str]
1562         auth_type : str
1563         redacted : typing.Sequence<+T_co>[str]
1564         '''
1565         self.attrs = attrs
1566         self.auth_type = auth_type
1567         self.redacted = redacted
1568
1569
1570
1571 class CloudCredentialResult(Type):
1572     _toSchema = {'error': 'error', 'result': 'result'}
1573     _toPy = {'error': 'error', 'result': 'result'}
1574     def __init__(self, error=None, result=None):
1575         '''
1576         error : Error
1577         result : CloudCredential
1578         '''
1579         self.error = Error.from_json(error) if error else None
1580         self.result = CloudCredential.from_json(result) if result else None
1581
1582
1583
1584 class CloudCredentialResults(Type):
1585     _toSchema = {'results': 'results'}
1586     _toPy = {'results': 'results'}
1587     def __init__(self, results=None):
1588         '''
1589         results : typing.Sequence<+T_co>[~CloudCredentialResult]<~CloudCredentialResult>
1590         '''
1591         self.results = [CloudCredentialResult.from_json(o) for o in results or []]
1592
1593
1594
1595 class CloudImageMetadata(Type):
1596     _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'}
1597     _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'}
1598     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):
1599         '''
1600         arch : str
1601         image_id : str
1602         priority : int
1603         region : str
1604         root_storage_size : int
1605         root_storage_type : str
1606         series : str
1607         source : str
1608         stream : str
1609         version : str
1610         virt_type : str
1611         '''
1612         self.arch = arch
1613         self.image_id = image_id
1614         self.priority = priority
1615         self.region = region
1616         self.root_storage_size = root_storage_size
1617         self.root_storage_type = root_storage_type
1618         self.series = series
1619         self.source = source
1620         self.stream = stream
1621         self.version = version
1622         self.virt_type = virt_type
1623
1624
1625
1626 class CloudImageMetadataList(Type):
1627     _toSchema = {'metadata': 'metadata'}
1628     _toPy = {'metadata': 'metadata'}
1629     def __init__(self, metadata=None):
1630         '''
1631         metadata : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
1632         '''
1633         self.metadata = [CloudImageMetadata.from_json(o) for o in metadata or []]
1634
1635
1636
1637 class CloudInstanceTypesConstraint(Type):
1638     _toSchema = {'cloud_tag': 'cloud-tag', 'constraints': 'constraints', 'region': 'region'}
1639     _toPy = {'cloud-tag': 'cloud_tag', 'constraints': 'constraints', 'region': 'region'}
1640     def __init__(self, cloud_tag=None, constraints=None, region=None):
1641         '''
1642         cloud_tag : str
1643         constraints : Value
1644         region : str
1645         '''
1646         self.cloud_tag = cloud_tag
1647         self.constraints = Value.from_json(constraints) if constraints else None
1648         self.region = region
1649
1650
1651
1652 class CloudInstanceTypesConstraints(Type):
1653     _toSchema = {'constraints': 'constraints'}
1654     _toPy = {'constraints': 'constraints'}
1655     def __init__(self, constraints=None):
1656         '''
1657         constraints : typing.Sequence<+T_co>[~CloudInstanceTypesConstraint]<~CloudInstanceTypesConstraint>
1658         '''
1659         self.constraints = [CloudInstanceTypesConstraint.from_json(o) for o in constraints or []]
1660
1661
1662
1663 class CloudRegion(Type):
1664     _toSchema = {'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'name': 'name', 'storage_endpoint': 'storage-endpoint'}
1665     _toPy = {'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'name': 'name', 'storage-endpoint': 'storage_endpoint'}
1666     def __init__(self, endpoint=None, identity_endpoint=None, name=None, storage_endpoint=None):
1667         '''
1668         endpoint : str
1669         identity_endpoint : str
1670         name : str
1671         storage_endpoint : str
1672         '''
1673         self.endpoint = endpoint
1674         self.identity_endpoint = identity_endpoint
1675         self.name = name
1676         self.storage_endpoint = storage_endpoint
1677
1678
1679
1680 class CloudResult(Type):
1681     _toSchema = {'cloud': 'cloud', 'error': 'error'}
1682     _toPy = {'cloud': 'cloud', 'error': 'error'}
1683     def __init__(self, cloud=None, error=None):
1684         '''
1685         cloud : Cloud
1686         error : Error
1687         '''
1688         self.cloud = Cloud.from_json(cloud) if cloud else None
1689         self.error = Error.from_json(error) if error else None
1690
1691
1692
1693 class CloudResults(Type):
1694     _toSchema = {'results': 'results'}
1695     _toPy = {'results': 'results'}
1696     def __init__(self, results=None):
1697         '''
1698         results : typing.Sequence<+T_co>[~CloudResult]<~CloudResult>
1699         '''
1700         self.results = [CloudResult.from_json(o) for o in results or []]
1701
1702
1703
1704 class CloudSpec(Type):
1705     _toSchema = {'credential': 'credential', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'name': 'name', 'region': 'region', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
1706     _toPy = {'credential': 'credential', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'name': 'name', 'region': 'region', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
1707     def __init__(self, credential=None, endpoint=None, identity_endpoint=None, name=None, region=None, storage_endpoint=None, type_=None):
1708         '''
1709         credential : CloudCredential
1710         endpoint : str
1711         identity_endpoint : str
1712         name : str
1713         region : str
1714         storage_endpoint : str
1715         type_ : str
1716         '''
1717         self.credential = CloudCredential.from_json(credential) if credential else None
1718         self.endpoint = endpoint
1719         self.identity_endpoint = identity_endpoint
1720         self.name = name
1721         self.region = region
1722         self.storage_endpoint = storage_endpoint
1723         self.type_ = type_
1724
1725
1726
1727 class CloudSpecResult(Type):
1728     _toSchema = {'error': 'error', 'result': 'result'}
1729     _toPy = {'error': 'error', 'result': 'result'}
1730     def __init__(self, error=None, result=None):
1731         '''
1732         error : Error
1733         result : CloudSpec
1734         '''
1735         self.error = Error.from_json(error) if error else None
1736         self.result = CloudSpec.from_json(result) if result else None
1737
1738
1739
1740 class CloudSpecResults(Type):
1741     _toSchema = {'results': 'results'}
1742     _toPy = {'results': 'results'}
1743     def __init__(self, results=None):
1744         '''
1745         results : typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
1746         '''
1747         self.results = [CloudSpecResult.from_json(o) for o in results or []]
1748
1749
1750
1751 class CloudsResult(Type):
1752     _toSchema = {'clouds': 'clouds'}
1753     _toPy = {'clouds': 'clouds'}
1754     def __init__(self, clouds=None):
1755         '''
1756         clouds : typing.Mapping<~KT, +VT_co>[str, ~Cloud]<~Cloud>
1757         '''
1758         self.clouds = clouds
1759
1760
1761
1762 class ConfigSettingsResult(Type):
1763     _toSchema = {'error': 'error', 'settings': 'settings'}
1764     _toPy = {'error': 'error', 'settings': 'settings'}
1765     def __init__(self, error=None, settings=None):
1766         '''
1767         error : Error
1768         settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
1769         '''
1770         self.error = Error.from_json(error) if error else None
1771         self.settings = settings
1772
1773
1774
1775 class ConfigSettingsResults(Type):
1776     _toSchema = {'results': 'results'}
1777     _toPy = {'results': 'results'}
1778     def __init__(self, results=None):
1779         '''
1780         results : typing.Sequence<+T_co>[~ConfigSettingsResult]<~ConfigSettingsResult>
1781         '''
1782         self.results = [ConfigSettingsResult.from_json(o) for o in results or []]
1783
1784
1785
1786 class ConfigValue(Type):
1787     _toSchema = {'source': 'source', 'value': 'value'}
1788     _toPy = {'source': 'source', 'value': 'value'}
1789     def __init__(self, source=None, value=None):
1790         '''
1791         source : str
1792         value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
1793         '''
1794         self.source = source
1795         self.value = value
1796
1797
1798
1799 class Constraints(Type):
1800     _toSchema = {'count': 'Count', 'pool': 'Pool', 'size': 'Size'}
1801     _toPy = {'Count': 'count', 'Pool': 'pool', 'Size': 'size'}
1802     def __init__(self, count=None, pool=None, size=None):
1803         '''
1804         count : int
1805         pool : str
1806         size : int
1807         '''
1808         self.count = count
1809         self.pool = pool
1810         self.size = size
1811
1812
1813
1814 class ConstraintsResult(Type):
1815     _toSchema = {'constraints': 'constraints', 'error': 'error'}
1816     _toPy = {'constraints': 'constraints', 'error': 'error'}
1817     def __init__(self, constraints=None, error=None):
1818         '''
1819         constraints : Value
1820         error : Error
1821         '''
1822         self.constraints = Value.from_json(constraints) if constraints else None
1823         self.error = Error.from_json(error) if error else None
1824
1825
1826
1827 class ConstraintsResults(Type):
1828     _toSchema = {'results': 'results'}
1829     _toPy = {'results': 'results'}
1830     def __init__(self, results=None):
1831         '''
1832         results : typing.Sequence<+T_co>[~ConstraintsResult]<~ConstraintsResult>
1833         '''
1834         self.results = [ConstraintsResult.from_json(o) for o in results or []]
1835
1836
1837
1838 class ConsumeApplicationArg(Type):
1839     _toSchema = {'application_alias': 'application-alias', 'application_url': 'application-url'}
1840     _toPy = {'application-alias': 'application_alias', 'application-url': 'application_url'}
1841     def __init__(self, application_alias=None, application_url=None):
1842         '''
1843         application_alias : str
1844         application_url : str
1845         '''
1846         self.application_alias = application_alias
1847         self.application_url = application_url
1848
1849
1850
1851 class ConsumeApplicationArgs(Type):
1852     _toSchema = {'args': 'args'}
1853     _toPy = {'args': 'args'}
1854     def __init__(self, args=None):
1855         '''
1856         args : typing.Sequence<+T_co>[~ConsumeApplicationArg]<~ConsumeApplicationArg>
1857         '''
1858         self.args = [ConsumeApplicationArg.from_json(o) for o in args or []]
1859
1860
1861
1862 class ConsumeApplicationResult(Type):
1863     _toSchema = {'error': 'error', 'local_name': 'local-name'}
1864     _toPy = {'error': 'error', 'local-name': 'local_name'}
1865     def __init__(self, error=None, local_name=None):
1866         '''
1867         error : Error
1868         local_name : str
1869         '''
1870         self.error = Error.from_json(error) if error else None
1871         self.local_name = local_name
1872
1873
1874
1875 class ConsumeApplicationResults(Type):
1876     _toSchema = {'results': 'results'}
1877     _toPy = {'results': 'results'}
1878     def __init__(self, results=None):
1879         '''
1880         results : typing.Sequence<+T_co>[~ConsumeApplicationResult]<~ConsumeApplicationResult>
1881         '''
1882         self.results = [ConsumeApplicationResult.from_json(o) for o in results or []]
1883
1884
1885
1886 class ContainerConfig(Type):
1887     _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'}
1888     _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'}
1889     def __init__(self, updatebehavior=None, apt_mirror=None, apt_proxy=None, authorized_keys=None, provider_type=None, proxy=None, ssl_hostname_verification=None):
1890         '''
1891         updatebehavior : UpdateBehavior
1892         apt_mirror : str
1893         apt_proxy : Settings
1894         authorized_keys : str
1895         provider_type : str
1896         proxy : Settings
1897         ssl_hostname_verification : bool
1898         '''
1899         self.updatebehavior = UpdateBehavior.from_json(updatebehavior) if updatebehavior else None
1900         self.apt_mirror = apt_mirror
1901         self.apt_proxy = Settings.from_json(apt_proxy) if apt_proxy else None
1902         self.authorized_keys = authorized_keys
1903         self.provider_type = provider_type
1904         self.proxy = Settings.from_json(proxy) if proxy else None
1905         self.ssl_hostname_verification = ssl_hostname_verification
1906
1907
1908
1909 class ContainerManagerConfig(Type):
1910     _toSchema = {'config': 'config'}
1911     _toPy = {'config': 'config'}
1912     def __init__(self, config=None):
1913         '''
1914         config : typing.Mapping<~KT, +VT_co>[str, str]
1915         '''
1916         self.config = config
1917
1918
1919
1920 class ContainerManagerConfigParams(Type):
1921     _toSchema = {'type_': 'type'}
1922     _toPy = {'type': 'type_'}
1923     def __init__(self, type_=None):
1924         '''
1925         type_ : str
1926         '''
1927         self.type_ = type_
1928
1929
1930
1931 class ControllerConfigResult(Type):
1932     _toSchema = {'config': 'config'}
1933     _toPy = {'config': 'config'}
1934     def __init__(self, config=None):
1935         '''
1936         config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
1937         '''
1938         self.config = config
1939
1940
1941
1942 class ControllersChangeResult(Type):
1943     _toSchema = {'error': 'error', 'result': 'result'}
1944     _toPy = {'error': 'error', 'result': 'result'}
1945     def __init__(self, error=None, result=None):
1946         '''
1947         error : Error
1948         result : ControllersChanges
1949         '''
1950         self.error = Error.from_json(error) if error else None
1951         self.result = ControllersChanges.from_json(result) if result else None
1952
1953
1954
1955 class ControllersChangeResults(Type):
1956     _toSchema = {'results': 'results'}
1957     _toPy = {'results': 'results'}
1958     def __init__(self, results=None):
1959         '''
1960         results : typing.Sequence<+T_co>[~ControllersChangeResult]<~ControllersChangeResult>
1961         '''
1962         self.results = [ControllersChangeResult.from_json(o) for o in results or []]
1963
1964
1965
1966 class ControllersChanges(Type):
1967     _toSchema = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
1968     _toPy = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
1969     def __init__(self, added=None, converted=None, demoted=None, maintained=None, promoted=None, removed=None):
1970         '''
1971         added : typing.Sequence<+T_co>[str]
1972         converted : typing.Sequence<+T_co>[str]
1973         demoted : typing.Sequence<+T_co>[str]
1974         maintained : typing.Sequence<+T_co>[str]
1975         promoted : typing.Sequence<+T_co>[str]
1976         removed : typing.Sequence<+T_co>[str]
1977         '''
1978         self.added = added
1979         self.converted = converted
1980         self.demoted = demoted
1981         self.maintained = maintained
1982         self.promoted = promoted
1983         self.removed = removed
1984
1985
1986
1987 class ControllersSpec(Type):
1988     _toSchema = {'constraints': 'constraints', 'num_controllers': 'num-controllers', 'placement': 'placement', 'series': 'series'}
1989     _toPy = {'constraints': 'constraints', 'num-controllers': 'num_controllers', 'placement': 'placement', 'series': 'series'}
1990     def __init__(self, constraints=None, num_controllers=None, placement=None, series=None):
1991         '''
1992         constraints : Value
1993         num_controllers : int
1994         placement : typing.Sequence<+T_co>[str]
1995         series : str
1996         '''
1997         self.constraints = Value.from_json(constraints) if constraints else None
1998         self.num_controllers = num_controllers
1999         self.placement = placement
2000         self.series = series
2001
2002
2003
2004 class ControllersSpecs(Type):
2005     _toSchema = {'specs': 'specs'}
2006     _toPy = {'specs': 'specs'}
2007     def __init__(self, specs=None):
2008         '''
2009         specs : typing.Sequence<+T_co>[~ControllersSpec]<~ControllersSpec>
2010         '''
2011         self.specs = [ControllersSpec.from_json(o) for o in specs or []]
2012
2013
2014
2015 class CreateSpaceParams(Type):
2016     _toSchema = {'provider_id': 'provider-id', 'public': 'public', 'space_tag': 'space-tag', 'subnet_tags': 'subnet-tags'}
2017     _toPy = {'provider-id': 'provider_id', 'public': 'public', 'space-tag': 'space_tag', 'subnet-tags': 'subnet_tags'}
2018     def __init__(self, provider_id=None, public=None, space_tag=None, subnet_tags=None):
2019         '''
2020         provider_id : str
2021         public : bool
2022         space_tag : str
2023         subnet_tags : typing.Sequence<+T_co>[str]
2024         '''
2025         self.provider_id = provider_id
2026         self.public = public
2027         self.space_tag = space_tag
2028         self.subnet_tags = subnet_tags
2029
2030
2031
2032 class CreateSpacesParams(Type):
2033     _toSchema = {'spaces': 'spaces'}
2034     _toPy = {'spaces': 'spaces'}
2035     def __init__(self, spaces=None):
2036         '''
2037         spaces : typing.Sequence<+T_co>[~CreateSpaceParams]<~CreateSpaceParams>
2038         '''
2039         self.spaces = [CreateSpaceParams.from_json(o) for o in spaces or []]
2040
2041
2042
2043 class Delta(Type):
2044     _toSchema = {'entity': 'entity', 'removed': 'removed'}
2045     _toPy = {'entity': 'entity', 'removed': 'removed'}
2046     def __init__(self, entity=None, removed=None):
2047         '''
2048         entity : typing.Mapping<~KT, +VT_co>[str, typing.Any]
2049         removed : bool
2050         '''
2051         self.entity = entity
2052         self.removed = removed
2053
2054
2055
2056 class DeployerConnectionValues(Type):
2057     _toSchema = {'api_addresses': 'api-addresses', 'state_addresses': 'state-addresses'}
2058     _toPy = {'api-addresses': 'api_addresses', 'state-addresses': 'state_addresses'}
2059     def __init__(self, api_addresses=None, state_addresses=None):
2060         '''
2061         api_addresses : typing.Sequence<+T_co>[str]
2062         state_addresses : typing.Sequence<+T_co>[str]
2063         '''
2064         self.api_addresses = api_addresses
2065         self.state_addresses = state_addresses
2066
2067
2068
2069 class DestroyApplicationInfo(Type):
2070     _toSchema = {'destroyed_storage': 'destroyed-storage', 'destroyed_units': 'destroyed-units', 'detached_storage': 'detached-storage'}
2071     _toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
2072     def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None):
2073         '''
2074         destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
2075         destroyed_units : typing.Sequence<+T_co>[~Entity]<~Entity>
2076         detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
2077         '''
2078         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
2079         self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
2080         self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
2081
2082
2083
2084 class DestroyApplicationResult(Type):
2085     _toSchema = {'error': 'error', 'info': 'info'}
2086     _toPy = {'error': 'error', 'info': 'info'}
2087     def __init__(self, error=None, info=None):
2088         '''
2089         error : Error
2090         info : DestroyApplicationInfo
2091         '''
2092         self.error = Error.from_json(error) if error else None
2093         self.info = DestroyApplicationInfo.from_json(info) if info else None
2094
2095
2096
2097 class DestroyApplicationResults(Type):
2098     _toSchema = {'results': 'results'}
2099     _toPy = {'results': 'results'}
2100     def __init__(self, results=None):
2101         '''
2102         results : typing.Sequence<+T_co>[~DestroyApplicationResult]<~DestroyApplicationResult>
2103         '''
2104         self.results = [DestroyApplicationResult.from_json(o) for o in results or []]
2105
2106
2107
2108 class DestroyApplicationUnits(Type):
2109     _toSchema = {'unit_names': 'unit-names'}
2110     _toPy = {'unit-names': 'unit_names'}
2111     def __init__(self, unit_names=None):
2112         '''
2113         unit_names : typing.Sequence<+T_co>[str]
2114         '''
2115         self.unit_names = unit_names
2116
2117
2118
2119 class DestroyControllerArgs(Type):
2120     _toSchema = {'destroy_models': 'destroy-models'}
2121     _toPy = {'destroy-models': 'destroy_models'}
2122     def __init__(self, destroy_models=None):
2123         '''
2124         destroy_models : bool
2125         '''
2126         self.destroy_models = destroy_models
2127
2128
2129
2130 class DestroyMachineInfo(Type):
2131     _toSchema = {'destroyed_storage': 'destroyed-storage', 'destroyed_units': 'destroyed-units', 'detached_storage': 'detached-storage'}
2132     _toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
2133     def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None):
2134         '''
2135         destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
2136         destroyed_units : typing.Sequence<+T_co>[~Entity]<~Entity>
2137         detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
2138         '''
2139         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
2140         self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
2141         self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
2142
2143
2144
2145 class DestroyMachineResult(Type):
2146     _toSchema = {'error': 'error', 'info': 'info'}
2147     _toPy = {'error': 'error', 'info': 'info'}
2148     def __init__(self, error=None, info=None):
2149         '''
2150         error : Error
2151         info : DestroyMachineInfo
2152         '''
2153         self.error = Error.from_json(error) if error else None
2154         self.info = DestroyMachineInfo.from_json(info) if info else None
2155
2156
2157
2158 class DestroyMachineResults(Type):
2159     _toSchema = {'results': 'results'}
2160     _toPy = {'results': 'results'}
2161     def __init__(self, results=None):
2162         '''
2163         results : typing.Sequence<+T_co>[~DestroyMachineResult]<~DestroyMachineResult>
2164         '''
2165         self.results = [DestroyMachineResult.from_json(o) for o in results or []]
2166
2167
2168
2169 class DestroyMachines(Type):
2170     _toSchema = {'force': 'force', 'machine_names': 'machine-names'}
2171     _toPy = {'force': 'force', 'machine-names': 'machine_names'}
2172     def __init__(self, force=None, machine_names=None):
2173         '''
2174         force : bool
2175         machine_names : typing.Sequence<+T_co>[str]
2176         '''
2177         self.force = force
2178         self.machine_names = machine_names
2179
2180
2181
2182 class DestroyRelation(Type):
2183     _toSchema = {'endpoints': 'endpoints'}
2184     _toPy = {'endpoints': 'endpoints'}
2185     def __init__(self, endpoints=None):
2186         '''
2187         endpoints : typing.Sequence<+T_co>[str]
2188         '''
2189         self.endpoints = endpoints
2190
2191
2192
2193 class DestroyUnitInfo(Type):
2194     _toSchema = {'destroyed_storage': 'destroyed-storage', 'detached_storage': 'detached-storage'}
2195     _toPy = {'destroyed-storage': 'destroyed_storage', 'detached-storage': 'detached_storage'}
2196     def __init__(self, destroyed_storage=None, detached_storage=None):
2197         '''
2198         destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
2199         detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
2200         '''
2201         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
2202         self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
2203
2204
2205
2206 class DestroyUnitResult(Type):
2207     _toSchema = {'error': 'error', 'info': 'info'}
2208     _toPy = {'error': 'error', 'info': 'info'}
2209     def __init__(self, error=None, info=None):
2210         '''
2211         error : Error
2212         info : DestroyUnitInfo
2213         '''
2214         self.error = Error.from_json(error) if error else None
2215         self.info = DestroyUnitInfo.from_json(info) if info else None
2216
2217
2218
2219 class DestroyUnitResults(Type):
2220     _toSchema = {'results': 'results'}
2221     _toPy = {'results': 'results'}
2222     def __init__(self, results=None):
2223         '''
2224         results : typing.Sequence<+T_co>[~DestroyUnitResult]<~DestroyUnitResult>
2225         '''
2226         self.results = [DestroyUnitResult.from_json(o) for o in results or []]
2227
2228
2229
2230 class DetailedStatus(Type):
2231     _toSchema = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
2232     _toPy = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
2233     def __init__(self, data=None, err=None, info=None, kind=None, life=None, since=None, status=None, version=None):
2234         '''
2235         data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
2236         err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
2237         info : str
2238         kind : str
2239         life : str
2240         since : str
2241         status : str
2242         version : str
2243         '''
2244         self.data = data
2245         self.err = err
2246         self.info = info
2247         self.kind = kind
2248         self.life = life
2249         self.since = since
2250         self.status = status
2251         self.version = version
2252
2253
2254
2255 class DeviceBridgeInfo(Type):
2256     _toSchema = {'bridge_name': 'bridge-name', 'host_device_name': 'host-device-name'}
2257     _toPy = {'bridge-name': 'bridge_name', 'host-device-name': 'host_device_name'}
2258     def __init__(self, bridge_name=None, host_device_name=None):
2259         '''
2260         bridge_name : str
2261         host_device_name : str
2262         '''
2263         self.bridge_name = bridge_name
2264         self.host_device_name = host_device_name
2265
2266
2267
2268 class DiscoverSpacesResults(Type):
2269     _toSchema = {'results': 'results'}
2270     _toPy = {'results': 'results'}
2271     def __init__(self, results=None):
2272         '''
2273         results : typing.Sequence<+T_co>[~ProviderSpace]<~ProviderSpace>
2274         '''
2275         self.results = [ProviderSpace.from_json(o) for o in results or []]
2276
2277
2278
2279 class DistributionGroupResult(Type):
2280     _toSchema = {'error': 'error', 'result': 'result'}
2281     _toPy = {'error': 'error', 'result': 'result'}
2282     def __init__(self, error=None, result=None):
2283         '''
2284         error : Error
2285         result : typing.Sequence<+T_co>[str]
2286         '''
2287         self.error = Error.from_json(error) if error else None
2288         self.result = result
2289
2290
2291
2292 class DistributionGroupResults(Type):
2293     _toSchema = {'results': 'results'}
2294     _toPy = {'results': 'results'}
2295     def __init__(self, results=None):
2296         '''
2297         results : typing.Sequence<+T_co>[~DistributionGroupResult]<~DistributionGroupResult>
2298         '''
2299         self.results = [DistributionGroupResult.from_json(o) for o in results or []]
2300
2301
2302
2303 class Endpoint(Type):
2304     _toSchema = {'application_name': 'application-name', 'relation': 'relation'}
2305     _toPy = {'application-name': 'application_name', 'relation': 'relation'}
2306     def __init__(self, application_name=None, relation=None):
2307         '''
2308         application_name : str
2309         relation : CharmRelation
2310         '''
2311         self.application_name = application_name
2312         self.relation = CharmRelation.from_json(relation) if relation else None
2313
2314
2315
2316 class EndpointStatus(Type):
2317     _toSchema = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
2318     _toPy = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
2319     def __init__(self, application=None, name=None, role=None, subordinate=None):
2320         '''
2321         application : str
2322         name : str
2323         role : str
2324         subordinate : bool
2325         '''
2326         self.application = application
2327         self.name = name
2328         self.role = role
2329         self.subordinate = subordinate
2330
2331
2332
2333 class Entities(Type):
2334     _toSchema = {'entities': 'entities'}
2335     _toPy = {'entities': 'entities'}
2336     def __init__(self, entities=None):
2337         '''
2338         entities : typing.Sequence<+T_co>[~Entity]<~Entity>
2339         '''
2340         self.entities = [Entity.from_json(o) for o in entities or []]
2341
2342
2343
2344 class EntitiesCharmURL(Type):
2345     _toSchema = {'entities': 'entities'}
2346     _toPy = {'entities': 'entities'}
2347     def __init__(self, entities=None):
2348         '''
2349         entities : typing.Sequence<+T_co>[~EntityCharmURL]<~EntityCharmURL>
2350         '''
2351         self.entities = [EntityCharmURL.from_json(o) for o in entities or []]
2352
2353
2354
2355 class EntitiesPortRanges(Type):
2356     _toSchema = {'entities': 'entities'}
2357     _toPy = {'entities': 'entities'}
2358     def __init__(self, entities=None):
2359         '''
2360         entities : typing.Sequence<+T_co>[~EntityPortRange]<~EntityPortRange>
2361         '''
2362         self.entities = [EntityPortRange.from_json(o) for o in entities or []]
2363
2364
2365
2366 class EntitiesResult(Type):
2367     _toSchema = {'entities': 'entities', 'error': 'error'}
2368     _toPy = {'entities': 'entities', 'error': 'error'}
2369     def __init__(self, entities=None, error=None):
2370         '''
2371         entities : typing.Sequence<+T_co>[~Entity]<~Entity>
2372         error : Error
2373         '''
2374         self.entities = [Entity.from_json(o) for o in entities or []]
2375         self.error = Error.from_json(error) if error else None
2376
2377
2378
2379 class EntitiesResults(Type):
2380     _toSchema = {'results': 'results'}
2381     _toPy = {'results': 'results'}
2382     def __init__(self, results=None):
2383         '''
2384         results : typing.Sequence<+T_co>[~EntitiesResult]<~EntitiesResult>
2385         '''
2386         self.results = [EntitiesResult.from_json(o) for o in results or []]
2387
2388
2389
2390 class EntitiesVersion(Type):
2391     _toSchema = {'agent_tools': 'agent-tools'}
2392     _toPy = {'agent-tools': 'agent_tools'}
2393     def __init__(self, agent_tools=None):
2394         '''
2395         agent_tools : typing.Sequence<+T_co>[~EntityVersion]<~EntityVersion>
2396         '''
2397         self.agent_tools = [EntityVersion.from_json(o) for o in agent_tools or []]
2398
2399
2400
2401 class EntitiesWatchResult(Type):
2402     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
2403     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
2404     def __init__(self, changes=None, error=None, watcher_id=None):
2405         '''
2406         changes : typing.Sequence<+T_co>[str]
2407         error : Error
2408         watcher_id : str
2409         '''
2410         self.changes = changes
2411         self.error = Error.from_json(error) if error else None
2412         self.watcher_id = watcher_id
2413
2414
2415
2416 class Entity(Type):
2417     _toSchema = {'tag': 'tag'}
2418     _toPy = {'tag': 'tag'}
2419     def __init__(self, tag=None):
2420         '''
2421         tag : str
2422         '''
2423         self.tag = tag
2424
2425
2426
2427 class EntityAnnotations(Type):
2428     _toSchema = {'annotations': 'annotations', 'entity': 'entity'}
2429     _toPy = {'annotations': 'annotations', 'entity': 'entity'}
2430     def __init__(self, annotations=None, entity=None):
2431         '''
2432         annotations : typing.Mapping<~KT, +VT_co>[str, str]
2433         entity : str
2434         '''
2435         self.annotations = annotations
2436         self.entity = entity
2437
2438
2439
2440 class EntityCharmURL(Type):
2441     _toSchema = {'charm_url': 'charm-url', 'tag': 'tag'}
2442     _toPy = {'charm-url': 'charm_url', 'tag': 'tag'}
2443     def __init__(self, charm_url=None, tag=None):
2444         '''
2445         charm_url : str
2446         tag : str
2447         '''
2448         self.charm_url = charm_url
2449         self.tag = tag
2450
2451
2452
2453 class EntityMetrics(Type):
2454     _toSchema = {'error': 'error', 'metrics': 'metrics'}
2455     _toPy = {'error': 'error', 'metrics': 'metrics'}
2456     def __init__(self, error=None, metrics=None):
2457         '''
2458         error : Error
2459         metrics : typing.Sequence<+T_co>[~MetricResult]<~MetricResult>
2460         '''
2461         self.error = Error.from_json(error) if error else None
2462         self.metrics = [MetricResult.from_json(o) for o in metrics or []]
2463
2464
2465
2466 class EntityPassword(Type):
2467     _toSchema = {'password': 'password', 'tag': 'tag'}
2468     _toPy = {'password': 'password', 'tag': 'tag'}
2469     def __init__(self, password=None, tag=None):
2470         '''
2471         password : str
2472         tag : str
2473         '''
2474         self.password = password
2475         self.tag = tag
2476
2477
2478
2479 class EntityPasswords(Type):
2480     _toSchema = {'changes': 'changes'}
2481     _toPy = {'changes': 'changes'}
2482     def __init__(self, changes=None):
2483         '''
2484         changes : typing.Sequence<+T_co>[~EntityPassword]<~EntityPassword>
2485         '''
2486         self.changes = [EntityPassword.from_json(o) for o in changes or []]
2487
2488
2489
2490 class EntityPortRange(Type):
2491     _toSchema = {'from_port': 'from-port', 'protocol': 'protocol', 'tag': 'tag', 'to_port': 'to-port'}
2492     _toPy = {'from-port': 'from_port', 'protocol': 'protocol', 'tag': 'tag', 'to-port': 'to_port'}
2493     def __init__(self, from_port=None, protocol=None, tag=None, to_port=None):
2494         '''
2495         from_port : int
2496         protocol : str
2497         tag : str
2498         to_port : int
2499         '''
2500         self.from_port = from_port
2501         self.protocol = protocol
2502         self.tag = tag
2503         self.to_port = to_port
2504
2505
2506
2507 class EntityStatus(Type):
2508     _toSchema = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
2509     _toPy = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
2510     def __init__(self, data=None, info=None, since=None, status=None):
2511         '''
2512         data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
2513         info : str
2514         since : str
2515         status : str
2516         '''
2517         self.data = data
2518         self.info = info
2519         self.since = since
2520         self.status = status
2521
2522
2523
2524 class EntityStatusArgs(Type):
2525     _toSchema = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
2526     _toPy = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
2527     def __init__(self, data=None, info=None, status=None, tag=None):
2528         '''
2529         data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
2530         info : str
2531         status : str
2532         tag : str
2533         '''
2534         self.data = data
2535         self.info = info
2536         self.status = status
2537         self.tag = tag
2538
2539
2540
2541 class EntityVersion(Type):
2542     _toSchema = {'tag': 'tag', 'tools': 'tools'}
2543     _toPy = {'tag': 'tag', 'tools': 'tools'}
2544     def __init__(self, tag=None, tools=None):
2545         '''
2546         tag : str
2547         tools : Version
2548         '''
2549         self.tag = tag
2550         self.tools = Version.from_json(tools) if tools else None
2551
2552
2553
2554 class EntityWorkloadVersion(Type):
2555     _toSchema = {'tag': 'tag', 'workload_version': 'workload-version'}
2556     _toPy = {'tag': 'tag', 'workload-version': 'workload_version'}
2557     def __init__(self, tag=None, workload_version=None):
2558         '''
2559         tag : str
2560         workload_version : str
2561         '''
2562         self.tag = tag
2563         self.workload_version = workload_version
2564
2565
2566
2567 class EntityWorkloadVersions(Type):
2568     _toSchema = {'entities': 'entities'}
2569     _toPy = {'entities': 'entities'}
2570     def __init__(self, entities=None):
2571         '''
2572         entities : typing.Sequence<+T_co>[~EntityWorkloadVersion]<~EntityWorkloadVersion>
2573         '''
2574         self.entities = [EntityWorkloadVersion.from_json(o) for o in entities or []]
2575
2576
2577
2578 class EnvListArgs(Type):
2579     _toSchema = {'patterns': 'patterns'}
2580     _toPy = {'patterns': 'patterns'}
2581     def __init__(self, patterns=None):
2582         '''
2583         patterns : typing.Sequence<+T_co>[str]
2584         '''
2585         self.patterns = patterns
2586
2587
2588
2589 class EnvListResults(Type):
2590     _toSchema = {'results': 'results'}
2591     _toPy = {'results': 'results'}
2592     def __init__(self, results=None):
2593         '''
2594         results : typing.Sequence<+T_co>[~Payload]<~Payload>
2595         '''
2596         self.results = [Payload.from_json(o) for o in results or []]
2597
2598
2599
2600 class Error(Type):
2601     _toSchema = {'code': 'code', 'info': 'info', 'message': 'message'}
2602     _toPy = {'code': 'code', 'info': 'info', 'message': 'message'}
2603     def __init__(self, code=None, info=None, message=None):
2604         '''
2605         code : str
2606         info : ErrorInfo
2607         message : str
2608         '''
2609         self.code = code
2610         self.info = ErrorInfo.from_json(info) if info else None
2611         self.message = message
2612
2613
2614
2615 class ErrorInfo(Type):
2616     _toSchema = {'macaroon': 'macaroon', 'macaroon_path': 'macaroon-path'}
2617     _toPy = {'macaroon': 'macaroon', 'macaroon-path': 'macaroon_path'}
2618     def __init__(self, macaroon=None, macaroon_path=None):
2619         '''
2620         macaroon : Macaroon
2621         macaroon_path : str
2622         '''
2623         self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
2624         self.macaroon_path = macaroon_path
2625
2626
2627
2628 class ErrorResult(Type):
2629     _toSchema = {'error': 'error'}
2630     _toPy = {'error': 'error'}
2631     def __init__(self, error=None):
2632         '''
2633         error : Error
2634         '''
2635         self.error = Error.from_json(error) if error else None
2636
2637
2638
2639 class ErrorResults(Type):
2640     _toSchema = {'results': 'results'}
2641     _toPy = {'results': 'results'}
2642     def __init__(self, results=None):
2643         '''
2644         results : typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
2645         '''
2646         self.results = [ErrorResult.from_json(o) for o in results or []]
2647
2648
2649
2650 class Filesystem(Type):
2651     _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'volume_tag': 'volume-tag'}
2652     _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'volume-tag': 'volume_tag'}
2653     def __init__(self, filesystem_tag=None, info=None, volume_tag=None):
2654         '''
2655         filesystem_tag : str
2656         info : FilesystemInfo
2657         volume_tag : str
2658         '''
2659         self.filesystem_tag = filesystem_tag
2660         self.info = FilesystemInfo.from_json(info) if info else None
2661         self.volume_tag = volume_tag
2662
2663
2664
2665 class FilesystemAttachment(Type):
2666     _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'machine_tag': 'machine-tag'}
2667     _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'machine-tag': 'machine_tag'}
2668     def __init__(self, filesystem_tag=None, info=None, machine_tag=None):
2669         '''
2670         filesystem_tag : str
2671         info : FilesystemAttachmentInfo
2672         machine_tag : str
2673         '''
2674         self.filesystem_tag = filesystem_tag
2675         self.info = FilesystemAttachmentInfo.from_json(info) if info else None
2676         self.machine_tag = machine_tag
2677
2678
2679
2680 class FilesystemAttachmentDetails(Type):
2681     _toSchema = {'filesystemattachmentinfo': 'FilesystemAttachmentInfo', 'life': 'life'}
2682     _toPy = {'FilesystemAttachmentInfo': 'filesystemattachmentinfo', 'life': 'life'}
2683     def __init__(self, filesystemattachmentinfo=None, life=None):
2684         '''
2685         filesystemattachmentinfo : FilesystemAttachmentInfo
2686         life : str
2687         '''
2688         self.filesystemattachmentinfo = FilesystemAttachmentInfo.from_json(filesystemattachmentinfo) if filesystemattachmentinfo else None
2689         self.life = life
2690
2691
2692
2693 class FilesystemAttachmentInfo(Type):
2694     _toSchema = {'mount_point': 'mount-point', 'read_only': 'read-only'}
2695     _toPy = {'mount-point': 'mount_point', 'read-only': 'read_only'}
2696     def __init__(self, mount_point=None, read_only=None):
2697         '''
2698         mount_point : str
2699         read_only : bool
2700         '''
2701         self.mount_point = mount_point
2702         self.read_only = read_only
2703
2704
2705
2706 class FilesystemAttachmentParams(Type):
2707     _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'}
2708     _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'}
2709     def __init__(self, filesystem_id=None, filesystem_tag=None, instance_id=None, machine_tag=None, mount_point=None, provider=None, read_only=None):
2710         '''
2711         filesystem_id : str
2712         filesystem_tag : str
2713         instance_id : str
2714         machine_tag : str
2715         mount_point : str
2716         provider : str
2717         read_only : bool
2718         '''
2719         self.filesystem_id = filesystem_id
2720         self.filesystem_tag = filesystem_tag
2721         self.instance_id = instance_id
2722         self.machine_tag = machine_tag
2723         self.mount_point = mount_point
2724         self.provider = provider
2725         self.read_only = read_only
2726
2727
2728
2729 class FilesystemAttachmentParamsResult(Type):
2730     _toSchema = {'error': 'error', 'result': 'result'}
2731     _toPy = {'error': 'error', 'result': 'result'}
2732     def __init__(self, error=None, result=None):
2733         '''
2734         error : Error
2735         result : FilesystemAttachmentParams
2736         '''
2737         self.error = Error.from_json(error) if error else None
2738         self.result = FilesystemAttachmentParams.from_json(result) if result else None
2739
2740
2741
2742 class FilesystemAttachmentParamsResults(Type):
2743     _toSchema = {'results': 'results'}
2744     _toPy = {'results': 'results'}
2745     def __init__(self, results=None):
2746         '''
2747         results : typing.Sequence<+T_co>[~FilesystemAttachmentParamsResult]<~FilesystemAttachmentParamsResult>
2748         '''
2749         self.results = [FilesystemAttachmentParamsResult.from_json(o) for o in results or []]
2750
2751
2752
2753 class FilesystemAttachmentResult(Type):
2754     _toSchema = {'error': 'error', 'result': 'result'}
2755     _toPy = {'error': 'error', 'result': 'result'}
2756     def __init__(self, error=None, result=None):
2757         '''
2758         error : Error
2759         result : FilesystemAttachment
2760         '''
2761         self.error = Error.from_json(error) if error else None
2762         self.result = FilesystemAttachment.from_json(result) if result else None
2763
2764
2765
2766 class FilesystemAttachmentResults(Type):
2767     _toSchema = {'results': 'results'}
2768     _toPy = {'results': 'results'}
2769     def __init__(self, results=None):
2770         '''
2771         results : typing.Sequence<+T_co>[~FilesystemAttachmentResult]<~FilesystemAttachmentResult>
2772         '''
2773         self.results = [FilesystemAttachmentResult.from_json(o) for o in results or []]
2774
2775
2776
2777 class FilesystemAttachments(Type):
2778     _toSchema = {'filesystem_attachments': 'filesystem-attachments'}
2779     _toPy = {'filesystem-attachments': 'filesystem_attachments'}
2780     def __init__(self, filesystem_attachments=None):
2781         '''
2782         filesystem_attachments : typing.Sequence<+T_co>[~FilesystemAttachment]<~FilesystemAttachment>
2783         '''
2784         self.filesystem_attachments = [FilesystemAttachment.from_json(o) for o in filesystem_attachments or []]
2785
2786
2787
2788 class FilesystemDetails(Type):
2789     _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'volume_tag': 'volume-tag'}
2790     _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'machine-attachments': 'machine_attachments', 'status': 'status', 'storage': 'storage', 'volume-tag': 'volume_tag'}
2791     def __init__(self, filesystem_tag=None, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None):
2792         '''
2793         filesystem_tag : str
2794         info : FilesystemInfo
2795         machine_attachments : typing.Mapping<~KT, +VT_co>[str, ~FilesystemAttachmentInfo]<~FilesystemAttachmentInfo>
2796         status : EntityStatus
2797         storage : StorageDetails
2798         volume_tag : str
2799         '''
2800         self.filesystem_tag = filesystem_tag
2801         self.info = FilesystemInfo.from_json(info) if info else None
2802         self.machine_attachments = machine_attachments
2803         self.status = EntityStatus.from_json(status) if status else None
2804         self.storage = StorageDetails.from_json(storage) if storage else None
2805         self.volume_tag = volume_tag
2806
2807
2808
2809 class FilesystemDetailsListResult(Type):
2810     _toSchema = {'error': 'error', 'result': 'result'}
2811     _toPy = {'error': 'error', 'result': 'result'}
2812     def __init__(self, error=None, result=None):
2813         '''
2814         error : Error
2815         result : typing.Sequence<+T_co>[~FilesystemDetails]<~FilesystemDetails>
2816         '''
2817         self.error = Error.from_json(error) if error else None
2818         self.result = [FilesystemDetails.from_json(o) for o in result or []]
2819
2820
2821
2822 class FilesystemDetailsListResults(Type):
2823     _toSchema = {'results': 'results'}
2824     _toPy = {'results': 'results'}
2825     def __init__(self, results=None):
2826         '''
2827         results : typing.Sequence<+T_co>[~FilesystemDetailsListResult]<~FilesystemDetailsListResult>
2828         '''
2829         self.results = [FilesystemDetailsListResult.from_json(o) for o in results or []]
2830
2831
2832
2833 class FilesystemFilter(Type):
2834     _toSchema = {'machines': 'machines'}
2835     _toPy = {'machines': 'machines'}
2836     def __init__(self, machines=None):
2837         '''
2838         machines : typing.Sequence<+T_co>[str]
2839         '''
2840         self.machines = machines
2841
2842
2843
2844 class FilesystemFilters(Type):
2845     _toSchema = {'filters': 'filters'}
2846     _toPy = {'filters': 'filters'}
2847     def __init__(self, filters=None):
2848         '''
2849         filters : typing.Sequence<+T_co>[~FilesystemFilter]<~FilesystemFilter>
2850         '''
2851         self.filters = [FilesystemFilter.from_json(o) for o in filters or []]
2852
2853
2854
2855 class FilesystemInfo(Type):
2856     _toSchema = {'filesystem_id': 'filesystem-id', 'size': 'size'}
2857     _toPy = {'filesystem-id': 'filesystem_id', 'size': 'size'}
2858     def __init__(self, filesystem_id=None, size=None):
2859         '''
2860         filesystem_id : str
2861         size : int
2862         '''
2863         self.filesystem_id = filesystem_id
2864         self.size = size
2865
2866
2867
2868 class FilesystemParams(Type):
2869     _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem_tag': 'filesystem-tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume_tag': 'volume-tag'}
2870     _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem-tag': 'filesystem_tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume-tag': 'volume_tag'}
2871     def __init__(self, attachment=None, attributes=None, filesystem_tag=None, provider=None, size=None, tags=None, volume_tag=None):
2872         '''
2873         attachment : FilesystemAttachmentParams
2874         attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
2875         filesystem_tag : str
2876         provider : str
2877         size : int
2878         tags : typing.Mapping<~KT, +VT_co>[str, str]
2879         volume_tag : str
2880         '''
2881         self.attachment = FilesystemAttachmentParams.from_json(attachment) if attachment else None
2882         self.attributes = attributes
2883         self.filesystem_tag = filesystem_tag
2884         self.provider = provider
2885         self.size = size
2886         self.tags = tags
2887         self.volume_tag = volume_tag
2888
2889
2890
2891 class FilesystemParamsResult(Type):
2892     _toSchema = {'error': 'error', 'result': 'result'}
2893     _toPy = {'error': 'error', 'result': 'result'}
2894     def __init__(self, error=None, result=None):
2895         '''
2896         error : Error
2897         result : FilesystemParams
2898         '''
2899         self.error = Error.from_json(error) if error else None
2900         self.result = FilesystemParams.from_json(result) if result else None
2901
2902
2903
2904 class FilesystemParamsResults(Type):
2905     _toSchema = {'results': 'results'}
2906     _toPy = {'results': 'results'}
2907     def __init__(self, results=None):
2908         '''
2909         results : typing.Sequence<+T_co>[~FilesystemParamsResult]<~FilesystemParamsResult>
2910         '''
2911         self.results = [FilesystemParamsResult.from_json(o) for o in results or []]
2912
2913
2914
2915 class FilesystemResult(Type):
2916     _toSchema = {'error': 'error', 'result': 'result'}
2917     _toPy = {'error': 'error', 'result': 'result'}
2918     def __init__(self, error=None, result=None):
2919         '''
2920         error : Error
2921         result : Filesystem
2922         '''
2923         self.error = Error.from_json(error) if error else None
2924         self.result = Filesystem.from_json(result) if result else None
2925
2926
2927
2928 class FilesystemResults(Type):
2929     _toSchema = {'results': 'results'}
2930     _toPy = {'results': 'results'}
2931     def __init__(self, results=None):
2932         '''
2933         results : typing.Sequence<+T_co>[~FilesystemResult]<~FilesystemResult>
2934         '''
2935         self.results = [FilesystemResult.from_json(o) for o in results or []]
2936
2937
2938
2939 class Filesystems(Type):
2940     _toSchema = {'filesystems': 'filesystems'}
2941     _toPy = {'filesystems': 'filesystems'}
2942     def __init__(self, filesystems=None):
2943         '''
2944         filesystems : typing.Sequence<+T_co>[~Filesystem]<~Filesystem>
2945         '''
2946         self.filesystems = [Filesystem.from_json(o) for o in filesystems or []]
2947
2948
2949
2950 class FindActionsByNames(Type):
2951     _toSchema = {'names': 'names'}
2952     _toPy = {'names': 'names'}
2953     def __init__(self, names=None):
2954         '''
2955         names : typing.Sequence<+T_co>[str]
2956         '''
2957         self.names = names
2958
2959
2960
2961 class FindTags(Type):
2962     _toSchema = {'prefixes': 'prefixes'}
2963     _toPy = {'prefixes': 'prefixes'}
2964     def __init__(self, prefixes=None):
2965         '''
2966         prefixes : typing.Sequence<+T_co>[str]
2967         '''
2968         self.prefixes = prefixes
2969
2970
2971
2972 class FindTagsResults(Type):
2973     _toSchema = {'matches': 'matches'}
2974     _toPy = {'matches': 'matches'}
2975     def __init__(self, matches=None):
2976         '''
2977         matches : typing.Sequence<+T_co>[~Entity]<~Entity>
2978         '''
2979         self.matches = [Entity.from_json(o) for o in matches or []]
2980
2981
2982
2983 class FindToolsParams(Type):
2984     _toSchema = {'arch': 'arch', 'major': 'major', 'minor': 'minor', 'number': 'number', 'series': 'series'}
2985     _toPy = {'arch': 'arch', 'major': 'major', 'minor': 'minor', 'number': 'number', 'series': 'series'}
2986     def __init__(self, arch=None, major=None, minor=None, number=None, series=None):
2987         '''
2988         arch : str
2989         major : int
2990         minor : int
2991         number : Number
2992         series : str
2993         '''
2994         self.arch = arch
2995         self.major = major
2996         self.minor = minor
2997         self.number = Number.from_json(number) if number else None
2998         self.series = series
2999
3000
3001
3002 class FindToolsResult(Type):
3003     _toSchema = {'error': 'error', 'list_': 'list'}
3004     _toPy = {'error': 'error', 'list': 'list_'}
3005     def __init__(self, error=None, list_=None):
3006         '''
3007         error : Error
3008         list_ : typing.Sequence<+T_co>[~Tools]<~Tools>
3009         '''
3010         self.error = Error.from_json(error) if error else None
3011         self.list_ = [Tools.from_json(o) for o in list_ or []]
3012
3013
3014
3015 class FullStatus(Type):
3016     _toSchema = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote_applications': 'remote-applications'}
3017     _toPy = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote-applications': 'remote_applications'}
3018     def __init__(self, applications=None, machines=None, model=None, relations=None, remote_applications=None):
3019         '''
3020         applications : typing.Mapping<~KT, +VT_co>[str, ~ApplicationStatus]<~ApplicationStatus>
3021         machines : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
3022         model : ModelStatusInfo
3023         relations : typing.Sequence<+T_co>[~RelationStatus]<~RelationStatus>
3024         remote_applications : typing.Mapping<~KT, +VT_co>[str, ~RemoteApplicationStatus]<~RemoteApplicationStatus>
3025         '''
3026         self.applications = applications
3027         self.machines = machines
3028         self.model = ModelStatusInfo.from_json(model) if model else None
3029         self.relations = [RelationStatus.from_json(o) for o in relations or []]
3030         self.remote_applications = remote_applications
3031
3032
3033
3034 class GetApplicationConstraints(Type):
3035     _toSchema = {'application': 'application'}
3036     _toPy = {'application': 'application'}
3037     def __init__(self, application=None):
3038         '''
3039         application : str
3040         '''
3041         self.application = application
3042
3043
3044
3045 class GetConstraintsResults(Type):
3046     _toSchema = {'constraints': 'constraints'}
3047     _toPy = {'constraints': 'constraints'}
3048     def __init__(self, constraints=None):
3049         '''
3050         constraints : Value
3051         '''
3052         self.constraints = Value.from_json(constraints) if constraints else None
3053
3054
3055
3056 class GetLeadershipSettingsBulkResults(Type):
3057     _toSchema = {'results': 'results'}
3058     _toPy = {'results': 'results'}
3059     def __init__(self, results=None):
3060         '''
3061         results : typing.Sequence<+T_co>[~GetLeadershipSettingsResult]<~GetLeadershipSettingsResult>
3062         '''
3063         self.results = [GetLeadershipSettingsResult.from_json(o) for o in results or []]
3064
3065
3066
3067 class GetLeadershipSettingsResult(Type):
3068     _toSchema = {'error': 'error', 'settings': 'settings'}
3069     _toPy = {'error': 'error', 'settings': 'settings'}
3070     def __init__(self, error=None, settings=None):
3071         '''
3072         error : Error
3073         settings : typing.Mapping<~KT, +VT_co>[str, str]
3074         '''
3075         self.error = Error.from_json(error) if error else None
3076         self.settings = settings
3077
3078
3079
3080 class HAMember(Type):
3081     _toSchema = {'public_address': 'public-address', 'series': 'series', 'tag': 'tag'}
3082     _toPy = {'public-address': 'public_address', 'series': 'series', 'tag': 'tag'}
3083     def __init__(self, public_address=None, series=None, tag=None):
3084         '''
3085         public_address : Address
3086         series : str
3087         tag : str
3088         '''
3089         self.public_address = Address.from_json(public_address) if public_address else None
3090         self.series = series
3091         self.tag = tag
3092
3093
3094
3095 class HardwareCharacteristics(Type):
3096     _toSchema = {'arch': 'arch', 'availability_zone': 'availability-zone', 'cpu_cores': 'cpu-cores', 'cpu_power': 'cpu-power', 'mem': 'mem', 'root_disk': 'root-disk', 'tags': 'tags'}
3097     _toPy = {'arch': 'arch', 'availability-zone': 'availability_zone', 'cpu-cores': 'cpu_cores', 'cpu-power': 'cpu_power', 'mem': 'mem', 'root-disk': 'root_disk', 'tags': 'tags'}
3098     def __init__(self, arch=None, availability_zone=None, cpu_cores=None, cpu_power=None, mem=None, root_disk=None, tags=None):
3099         '''
3100         arch : str
3101         availability_zone : str
3102         cpu_cores : int
3103         cpu_power : int
3104         mem : int
3105         root_disk : int
3106         tags : typing.Sequence<+T_co>[str]
3107         '''
3108         self.arch = arch
3109         self.availability_zone = availability_zone
3110         self.cpu_cores = cpu_cores
3111         self.cpu_power = cpu_power
3112         self.mem = mem
3113         self.root_disk = root_disk
3114         self.tags = tags
3115
3116
3117
3118 class History(Type):
3119     _toSchema = {'error': 'error', 'statuses': 'statuses'}
3120     _toPy = {'error': 'error', 'statuses': 'statuses'}
3121     def __init__(self, error=None, statuses=None):
3122         '''
3123         error : Error
3124         statuses : typing.Sequence<+T_co>[~DetailedStatus]<~DetailedStatus>
3125         '''
3126         self.error = Error.from_json(error) if error else None
3127         self.statuses = [DetailedStatus.from_json(o) for o in statuses or []]
3128
3129
3130
3131 class HostNetworkChange(Type):
3132     _toSchema = {'error': 'error', 'new_bridges': 'new-bridges', 'reconfigure_delay': 'reconfigure-delay'}
3133     _toPy = {'error': 'error', 'new-bridges': 'new_bridges', 'reconfigure-delay': 'reconfigure_delay'}
3134     def __init__(self, error=None, new_bridges=None, reconfigure_delay=None):
3135         '''
3136         error : Error
3137         new_bridges : typing.Sequence<+T_co>[~DeviceBridgeInfo]<~DeviceBridgeInfo>
3138         reconfigure_delay : int
3139         '''
3140         self.error = Error.from_json(error) if error else None
3141         self.new_bridges = [DeviceBridgeInfo.from_json(o) for o in new_bridges or []]
3142         self.reconfigure_delay = reconfigure_delay
3143
3144
3145
3146 class HostNetworkChangeResults(Type):
3147     _toSchema = {'results': 'results'}
3148     _toPy = {'results': 'results'}
3149     def __init__(self, results=None):
3150         '''
3151         results : typing.Sequence<+T_co>[~HostNetworkChange]<~HostNetworkChange>
3152         '''
3153         self.results = [HostNetworkChange.from_json(o) for o in results or []]
3154
3155
3156
3157 class HostPort(Type):
3158     _toSchema = {'address': 'Address', 'port': 'port'}
3159     _toPy = {'Address': 'address', 'port': 'port'}
3160     def __init__(self, address=None, port=None):
3161         '''
3162         address : Address
3163         port : int
3164         '''
3165         self.address = Address.from_json(address) if address else None
3166         self.port = port
3167
3168
3169
3170 class HostedModelConfig(Type):
3171     _toSchema = {'cloud_spec': 'cloud-spec', 'config': 'config', 'error': 'error', 'name': 'name', 'owner': 'owner'}
3172     _toPy = {'cloud-spec': 'cloud_spec', 'config': 'config', 'error': 'error', 'name': 'name', 'owner': 'owner'}
3173     def __init__(self, cloud_spec=None, config=None, error=None, name=None, owner=None):
3174         '''
3175         cloud_spec : CloudSpec
3176         config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
3177         error : Error
3178         name : str
3179         owner : str
3180         '''
3181         self.cloud_spec = CloudSpec.from_json(cloud_spec) if cloud_spec else None
3182         self.config = config
3183         self.error = Error.from_json(error) if error else None
3184         self.name = name
3185         self.owner = owner
3186
3187
3188
3189 class HostedModelConfigsResults(Type):
3190     _toSchema = {'models': 'models'}
3191     _toPy = {'models': 'models'}
3192     def __init__(self, models=None):
3193         '''
3194         models : typing.Sequence<+T_co>[~HostedModelConfig]<~HostedModelConfig>
3195         '''
3196         self.models = [HostedModelConfig.from_json(o) for o in models or []]
3197
3198
3199
3200 class ImageFilterParams(Type):
3201     _toSchema = {'images': 'images'}
3202     _toPy = {'images': 'images'}
3203     def __init__(self, images=None):
3204         '''
3205         images : typing.Sequence<+T_co>[~ImageSpec]<~ImageSpec>
3206         '''
3207         self.images = [ImageSpec.from_json(o) for o in images or []]
3208
3209
3210
3211 class ImageMetadata(Type):
3212     _toSchema = {'arch': 'arch', 'created': 'created', 'kind': 'kind', 'series': 'series', 'url': 'url'}
3213     _toPy = {'arch': 'arch', 'created': 'created', 'kind': 'kind', 'series': 'series', 'url': 'url'}
3214     def __init__(self, arch=None, created=None, kind=None, series=None, url=None):
3215         '''
3216         arch : str
3217         created : str
3218         kind : str
3219         series : str
3220         url : str
3221         '''
3222         self.arch = arch
3223         self.created = created
3224         self.kind = kind
3225         self.series = series
3226         self.url = url
3227
3228
3229
3230 class ImageMetadataFilter(Type):
3231     _toSchema = {'arches': 'arches', 'region': 'region', 'root_storage_type': 'root-storage-type', 'series': 'series', 'stream': 'stream', 'virt_type': 'virt-type'}
3232     _toPy = {'arches': 'arches', 'region': 'region', 'root-storage-type': 'root_storage_type', 'series': 'series', 'stream': 'stream', 'virt-type': 'virt_type'}
3233     def __init__(self, arches=None, region=None, root_storage_type=None, series=None, stream=None, virt_type=None):
3234         '''
3235         arches : typing.Sequence<+T_co>[str]
3236         region : str
3237         root_storage_type : str
3238         series : typing.Sequence<+T_co>[str]
3239         stream : str
3240         virt_type : str
3241         '''
3242         self.arches = arches
3243         self.region = region
3244         self.root_storage_type = root_storage_type
3245         self.series = series
3246         self.stream = stream
3247         self.virt_type = virt_type
3248
3249
3250
3251 class ImageSpec(Type):
3252     _toSchema = {'arch': 'arch', 'kind': 'kind', 'series': 'series'}
3253     _toPy = {'arch': 'arch', 'kind': 'kind', 'series': 'series'}
3254     def __init__(self, arch=None, kind=None, series=None):
3255         '''
3256         arch : str
3257         kind : str
3258         series : str
3259         '''
3260         self.arch = arch
3261         self.kind = kind
3262         self.series = series
3263
3264
3265
3266 class InitiateMigrationArgs(Type):
3267     _toSchema = {'specs': 'specs'}
3268     _toPy = {'specs': 'specs'}
3269     def __init__(self, specs=None):
3270         '''
3271         specs : typing.Sequence<+T_co>[~MigrationSpec]<~MigrationSpec>
3272         '''
3273         self.specs = [MigrationSpec.from_json(o) for o in specs or []]
3274
3275
3276
3277 class InitiateMigrationResult(Type):
3278     _toSchema = {'error': 'error', 'migration_id': 'migration-id', 'model_tag': 'model-tag'}
3279     _toPy = {'error': 'error', 'migration-id': 'migration_id', 'model-tag': 'model_tag'}
3280     def __init__(self, error=None, migration_id=None, model_tag=None):
3281         '''
3282         error : Error
3283         migration_id : str
3284         model_tag : str
3285         '''
3286         self.error = Error.from_json(error) if error else None
3287         self.migration_id = migration_id
3288         self.model_tag = model_tag
3289
3290
3291
3292 class InitiateMigrationResults(Type):
3293     _toSchema = {'results': 'results'}
3294     _toPy = {'results': 'results'}
3295     def __init__(self, results=None):
3296         '''
3297         results : typing.Sequence<+T_co>[~InitiateMigrationResult]<~InitiateMigrationResult>
3298         '''
3299         self.results = [InitiateMigrationResult.from_json(o) for o in results or []]
3300
3301
3302
3303 class InstanceInfo(Type):
3304     _toSchema = {'characteristics': 'characteristics', 'instance_id': 'instance-id', 'network_config': 'network-config', 'nonce': 'nonce', 'tag': 'tag', 'volume_attachments': 'volume-attachments', 'volumes': 'volumes'}
3305     _toPy = {'characteristics': 'characteristics', 'instance-id': 'instance_id', 'network-config': 'network_config', 'nonce': 'nonce', 'tag': 'tag', 'volume-attachments': 'volume_attachments', 'volumes': 'volumes'}
3306     def __init__(self, characteristics=None, instance_id=None, network_config=None, nonce=None, tag=None, volume_attachments=None, volumes=None):
3307         '''
3308         characteristics : HardwareCharacteristics
3309         instance_id : str
3310         network_config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
3311         nonce : str
3312         tag : str
3313         volume_attachments : typing.Mapping<~KT, +VT_co>[str, ~VolumeAttachmentInfo]<~VolumeAttachmentInfo>
3314         volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
3315         '''
3316         self.characteristics = HardwareCharacteristics.from_json(characteristics) if characteristics else None
3317         self.instance_id = instance_id
3318         self.network_config = [NetworkConfig.from_json(o) for o in network_config or []]
3319         self.nonce = nonce
3320         self.tag = tag
3321         self.volume_attachments = volume_attachments
3322         self.volumes = [Volume.from_json(o) for o in volumes or []]
3323
3324
3325
3326 class InstanceType(Type):
3327     _toSchema = {'arches': 'arches', 'cost': 'cost', 'cpu_cores': 'cpu-cores', 'deprecated': 'deprecated', 'memory': 'memory', 'name': 'name', 'root_disk': 'root-disk', 'virt_type': 'virt-type'}
3328     _toPy = {'arches': 'arches', 'cost': 'cost', 'cpu-cores': 'cpu_cores', 'deprecated': 'deprecated', 'memory': 'memory', 'name': 'name', 'root-disk': 'root_disk', 'virt-type': 'virt_type'}
3329     def __init__(self, arches=None, cost=None, cpu_cores=None, deprecated=None, memory=None, name=None, root_disk=None, virt_type=None):
3330         '''
3331         arches : typing.Sequence<+T_co>[str]
3332         cost : int
3333         cpu_cores : int
3334         deprecated : bool
3335         memory : int
3336         name : str
3337         root_disk : int
3338         virt_type : str
3339         '''
3340         self.arches = arches
3341         self.cost = cost
3342         self.cpu_cores = cpu_cores
3343         self.deprecated = deprecated
3344         self.memory = memory
3345         self.name = name
3346         self.root_disk = root_disk
3347         self.virt_type = virt_type
3348
3349
3350
3351 class InstanceTypesResult(Type):
3352     _toSchema = {'cost_currency': 'cost-currency', 'cost_divisor': 'cost-divisor', 'cost_unit': 'cost-unit', 'error': 'error', 'instance_types': 'instance-types'}
3353     _toPy = {'cost-currency': 'cost_currency', 'cost-divisor': 'cost_divisor', 'cost-unit': 'cost_unit', 'error': 'error', 'instance-types': 'instance_types'}
3354     def __init__(self, cost_currency=None, cost_divisor=None, cost_unit=None, error=None, instance_types=None):
3355         '''
3356         cost_currency : str
3357         cost_divisor : int
3358         cost_unit : str
3359         error : Error
3360         instance_types : typing.Sequence<+T_co>[~InstanceType]<~InstanceType>
3361         '''
3362         self.cost_currency = cost_currency
3363         self.cost_divisor = cost_divisor
3364         self.cost_unit = cost_unit
3365         self.error = Error.from_json(error) if error else None
3366         self.instance_types = [InstanceType.from_json(o) for o in instance_types or []]
3367
3368
3369
3370 class InstanceTypesResults(Type):
3371     _toSchema = {'results': 'results'}
3372     _toPy = {'results': 'results'}
3373     def __init__(self, results=None):
3374         '''
3375         results : typing.Sequence<+T_co>[~InstanceTypesResult]<~InstanceTypesResult>
3376         '''
3377         self.results = [InstanceTypesResult.from_json(o) for o in results or []]
3378
3379
3380
3381 class InstancesInfo(Type):
3382     _toSchema = {'machines': 'machines'}
3383     _toPy = {'machines': 'machines'}
3384     def __init__(self, machines=None):
3385         '''
3386         machines : typing.Sequence<+T_co>[~InstanceInfo]<~InstanceInfo>
3387         '''
3388         self.machines = [InstanceInfo.from_json(o) for o in machines or []]
3389
3390
3391
3392 class IntResult(Type):
3393     _toSchema = {'error': 'error', 'result': 'result'}
3394     _toPy = {'error': 'error', 'result': 'result'}
3395     def __init__(self, error=None, result=None):
3396         '''
3397         error : Error
3398         result : int
3399         '''
3400         self.error = Error.from_json(error) if error else None
3401         self.result = result
3402
3403
3404
3405 class IntResults(Type):
3406     _toSchema = {'results': 'results'}
3407     _toPy = {'results': 'results'}
3408     def __init__(self, results=None):
3409         '''
3410         results : typing.Sequence<+T_co>[~IntResult]<~IntResult>
3411         '''
3412         self.results = [IntResult.from_json(o) for o in results or []]
3413
3414
3415
3416 class IsMasterResult(Type):
3417     _toSchema = {'master': 'master'}
3418     _toPy = {'master': 'master'}
3419     def __init__(self, master=None):
3420         '''
3421         master : bool
3422         '''
3423         self.master = master
3424
3425
3426
3427 class IsMeteredResult(Type):
3428     _toSchema = {'metered': 'metered'}
3429     _toPy = {'metered': 'metered'}
3430     def __init__(self, metered=None):
3431         '''
3432         metered : bool
3433         '''
3434         self.metered = metered
3435
3436
3437
3438 class JobsResult(Type):
3439     _toSchema = {'error': 'error', 'jobs': 'jobs'}
3440     _toPy = {'error': 'error', 'jobs': 'jobs'}
3441     def __init__(self, error=None, jobs=None):
3442         '''
3443         error : Error
3444         jobs : typing.Sequence<+T_co>[str]
3445         '''
3446         self.error = Error.from_json(error) if error else None
3447         self.jobs = jobs
3448
3449
3450
3451 class JobsResults(Type):
3452     _toSchema = {'results': 'results'}
3453     _toPy = {'results': 'results'}
3454     def __init__(self, results=None):
3455         '''
3456         results : typing.Sequence<+T_co>[~JobsResult]<~JobsResult>
3457         '''
3458         self.results = [JobsResult.from_json(o) for o in results or []]
3459
3460
3461
3462 class LifeResult(Type):
3463     _toSchema = {'error': 'error', 'life': 'life'}
3464     _toPy = {'error': 'error', 'life': 'life'}
3465     def __init__(self, error=None, life=None):
3466         '''
3467         error : Error
3468         life : str
3469         '''
3470         self.error = Error.from_json(error) if error else None
3471         self.life = life
3472
3473
3474
3475 class LifeResults(Type):
3476     _toSchema = {'results': 'results'}
3477     _toPy = {'results': 'results'}
3478     def __init__(self, results=None):
3479         '''
3480         results : typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
3481         '''
3482         self.results = [LifeResult.from_json(o) for o in results or []]
3483
3484
3485
3486 class ListCloudImageMetadataResult(Type):
3487     _toSchema = {'result': 'result'}
3488     _toPy = {'result': 'result'}
3489     def __init__(self, result=None):
3490         '''
3491         result : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
3492         '''
3493         self.result = [CloudImageMetadata.from_json(o) for o in result or []]
3494
3495
3496
3497 class ListImageResult(Type):
3498     _toSchema = {'result': 'result'}
3499     _toPy = {'result': 'result'}
3500     def __init__(self, result=None):
3501         '''
3502         result : typing.Sequence<+T_co>[~ImageMetadata]<~ImageMetadata>
3503         '''
3504         self.result = [ImageMetadata.from_json(o) for o in result or []]
3505
3506
3507
3508 class ListResourcesArgs(Type):
3509     _toSchema = {'entities': 'entities'}
3510     _toPy = {'entities': 'entities'}
3511     def __init__(self, entities=None):
3512         '''
3513         entities : typing.Sequence<+T_co>[~Entity]<~Entity>
3514         '''
3515         self.entities = [Entity.from_json(o) for o in entities or []]
3516
3517
3518
3519 class ListSSHKeys(Type):
3520     _toSchema = {'entities': 'entities', 'mode': 'mode'}
3521     _toPy = {'entities': 'entities', 'mode': 'mode'}
3522     def __init__(self, entities=None, mode=None):
3523         '''
3524         entities : Entities
3525         mode : bool
3526         '''
3527         self.entities = Entities.from_json(entities) if entities else None
3528         self.mode = mode
3529
3530
3531
3532 class ListSpacesResults(Type):
3533     _toSchema = {'results': 'results'}
3534     _toPy = {'results': 'results'}
3535     def __init__(self, results=None):
3536         '''
3537         results : typing.Sequence<+T_co>[~Space]<~Space>
3538         '''
3539         self.results = [Space.from_json(o) for o in results or []]
3540
3541
3542
3543 class ListSubnetsResults(Type):
3544     _toSchema = {'results': 'results'}
3545     _toPy = {'results': 'results'}
3546     def __init__(self, results=None):
3547         '''
3548         results : typing.Sequence<+T_co>[~Subnet]<~Subnet>
3549         '''
3550         self.results = [Subnet.from_json(o) for o in results or []]
3551
3552
3553
3554 class ListUnitResourcesArgs(Type):
3555     _toSchema = {'resource_names': 'resource-names'}
3556     _toPy = {'resource-names': 'resource_names'}
3557     def __init__(self, resource_names=None):
3558         '''
3559         resource_names : typing.Sequence<+T_co>[str]
3560         '''
3561         self.resource_names = resource_names
3562
3563
3564
3565 class LogForwardingGetLastSentParams(Type):
3566     _toSchema = {'ids': 'ids'}
3567     _toPy = {'ids': 'ids'}
3568     def __init__(self, ids=None):
3569         '''
3570         ids : typing.Sequence<+T_co>[~LogForwardingID]<~LogForwardingID>
3571         '''
3572         self.ids = [LogForwardingID.from_json(o) for o in ids or []]
3573
3574
3575
3576 class LogForwardingGetLastSentResult(Type):
3577     _toSchema = {'err': 'err', 'record_id': 'record-id', 'record_timestamp': 'record-timestamp'}
3578     _toPy = {'err': 'err', 'record-id': 'record_id', 'record-timestamp': 'record_timestamp'}
3579     def __init__(self, err=None, record_id=None, record_timestamp=None):
3580         '''
3581         err : Error
3582         record_id : int
3583         record_timestamp : int
3584         '''
3585         self.err = Error.from_json(err) if err else None
3586         self.record_id = record_id
3587         self.record_timestamp = record_timestamp
3588
3589
3590
3591 class LogForwardingGetLastSentResults(Type):
3592     _toSchema = {'results': 'results'}
3593     _toPy = {'results': 'results'}
3594     def __init__(self, results=None):
3595         '''
3596         results : typing.Sequence<+T_co>[~LogForwardingGetLastSentResult]<~LogForwardingGetLastSentResult>
3597         '''
3598         self.results = [LogForwardingGetLastSentResult.from_json(o) for o in results or []]
3599
3600
3601
3602 class LogForwardingID(Type):
3603     _toSchema = {'model': 'model', 'sink': 'sink'}
3604     _toPy = {'model': 'model', 'sink': 'sink'}
3605     def __init__(self, model=None, sink=None):
3606         '''
3607         model : str
3608         sink : str
3609         '''
3610         self.model = model
3611         self.sink = sink
3612
3613
3614
3615 class LogForwardingSetLastSentParam(Type):
3616     _toSchema = {'logforwardingid': 'LogForwardingID', 'record_id': 'record-id', 'record_timestamp': 'record-timestamp'}
3617     _toPy = {'LogForwardingID': 'logforwardingid', 'record-id': 'record_id', 'record-timestamp': 'record_timestamp'}
3618     def __init__(self, logforwardingid=None, record_id=None, record_timestamp=None):
3619         '''
3620         logforwardingid : LogForwardingID
3621         record_id : int
3622         record_timestamp : int
3623         '''
3624         self.logforwardingid = LogForwardingID.from_json(logforwardingid) if logforwardingid else None
3625         self.record_id = record_id
3626         self.record_timestamp = record_timestamp
3627
3628
3629
3630 class LogForwardingSetLastSentParams(Type):
3631     _toSchema = {'params': 'params'}
3632     _toPy = {'params': 'params'}
3633     def __init__(self, params=None):
3634         '''
3635         params : typing.Sequence<+T_co>[~LogForwardingSetLastSentParam]<~LogForwardingSetLastSentParam>
3636         '''
3637         self.params = [LogForwardingSetLastSentParam.from_json(o) for o in params or []]
3638
3639
3640
3641 class LookUpArg(Type):
3642     _toSchema = {'id_': 'id', 'name': 'name'}
3643     _toPy = {'id': 'id_', 'name': 'name'}
3644     def __init__(self, id_=None, name=None):
3645         '''
3646         id_ : str
3647         name : str
3648         '''
3649         self.id_ = id_
3650         self.name = name
3651
3652
3653
3654 class LookUpArgs(Type):
3655     _toSchema = {'args': 'args'}
3656     _toPy = {'args': 'args'}
3657     def __init__(self, args=None):
3658         '''
3659         args : typing.Sequence<+T_co>[~LookUpArg]<~LookUpArg>
3660         '''
3661         self.args = [LookUpArg.from_json(o) for o in args or []]
3662
3663
3664
3665 class LookUpPayloadArg(Type):
3666     _toSchema = {'id_': 'id', 'name': 'name'}
3667     _toPy = {'id': 'id_', 'name': 'name'}
3668     def __init__(self, id_=None, name=None):
3669         '''
3670         id_ : str
3671         name : str
3672         '''
3673         self.id_ = id_
3674         self.name = name
3675
3676
3677
3678 class LookUpPayloadArgs(Type):
3679     _toSchema = {'args': 'args'}
3680     _toPy = {'args': 'args'}
3681     def __init__(self, args=None):
3682         '''
3683         args : typing.Sequence<+T_co>[~LookUpPayloadArg]<~LookUpPayloadArg>
3684         '''
3685         self.args = [LookUpPayloadArg.from_json(o) for o in args or []]
3686
3687
3688
3689 class Macaroon(Type):
3690     _toSchema = {}
3691     _toPy = {}
3692     def __init__(self):
3693         '''
3694
3695         '''
3696         pass
3697
3698
3699
3700 class MachineAddresses(Type):
3701     _toSchema = {'addresses': 'addresses', 'tag': 'tag'}
3702     _toPy = {'addresses': 'addresses', 'tag': 'tag'}
3703     def __init__(self, addresses=None, tag=None):
3704         '''
3705         addresses : typing.Sequence<+T_co>[~Address]<~Address>
3706         tag : str
3707         '''
3708         self.addresses = [Address.from_json(o) for o in addresses or []]
3709         self.tag = tag
3710
3711
3712
3713 class MachineAddressesResult(Type):
3714     _toSchema = {'addresses': 'addresses', 'error': 'error'}
3715     _toPy = {'addresses': 'addresses', 'error': 'error'}
3716     def __init__(self, addresses=None, error=None):
3717         '''
3718         addresses : typing.Sequence<+T_co>[~Address]<~Address>
3719         error : Error
3720         '''
3721         self.addresses = [Address.from_json(o) for o in addresses or []]
3722         self.error = Error.from_json(error) if error else None
3723
3724
3725
3726 class MachineAddressesResults(Type):
3727     _toSchema = {'results': 'results'}
3728     _toPy = {'results': 'results'}
3729     def __init__(self, results=None):
3730         '''
3731         results : typing.Sequence<+T_co>[~MachineAddressesResult]<~MachineAddressesResult>
3732         '''
3733         self.results = [MachineAddressesResult.from_json(o) for o in results or []]
3734
3735
3736
3737 class MachineBlockDevices(Type):
3738     _toSchema = {'block_devices': 'block-devices', 'machine': 'machine'}
3739     _toPy = {'block-devices': 'block_devices', 'machine': 'machine'}
3740     def __init__(self, block_devices=None, machine=None):
3741         '''
3742         block_devices : typing.Sequence<+T_co>[~BlockDevice]<~BlockDevice>
3743         machine : str
3744         '''
3745         self.block_devices = [BlockDevice.from_json(o) for o in block_devices or []]
3746         self.machine = machine
3747
3748
3749
3750 class MachineContainers(Type):
3751     _toSchema = {'container_types': 'container-types', 'machine_tag': 'machine-tag'}
3752     _toPy = {'container-types': 'container_types', 'machine-tag': 'machine_tag'}
3753     def __init__(self, container_types=None, machine_tag=None):
3754         '''
3755         container_types : typing.Sequence<+T_co>[str]
3756         machine_tag : str
3757         '''
3758         self.container_types = container_types
3759         self.machine_tag = machine_tag
3760
3761
3762
3763 class MachineContainersParams(Type):
3764     _toSchema = {'params': 'params'}
3765     _toPy = {'params': 'params'}
3766     def __init__(self, params=None):
3767         '''
3768         params : typing.Sequence<+T_co>[~MachineContainers]<~MachineContainers>
3769         '''
3770         self.params = [MachineContainers.from_json(o) for o in params or []]
3771
3772
3773
3774 class MachineHardware(Type):
3775     _toSchema = {'arch': 'arch', 'availability_zone': 'availability-zone', 'cores': 'cores', 'cpu_power': 'cpu-power', 'mem': 'mem', 'root_disk': 'root-disk', 'tags': 'tags'}
3776     _toPy = {'arch': 'arch', 'availability-zone': 'availability_zone', 'cores': 'cores', 'cpu-power': 'cpu_power', 'mem': 'mem', 'root-disk': 'root_disk', 'tags': 'tags'}
3777     def __init__(self, arch=None, availability_zone=None, cores=None, cpu_power=None, mem=None, root_disk=None, tags=None):
3778         '''
3779         arch : str
3780         availability_zone : str
3781         cores : int
3782         cpu_power : int
3783         mem : int
3784         root_disk : int
3785         tags : typing.Sequence<+T_co>[str]
3786         '''
3787         self.arch = arch
3788         self.availability_zone = availability_zone
3789         self.cores = cores
3790         self.cpu_power = cpu_power
3791         self.mem = mem
3792         self.root_disk = root_disk
3793         self.tags = tags
3794
3795
3796
3797 class MachineNetworkConfigResult(Type):
3798     _toSchema = {'error': 'error', 'info': 'info'}
3799     _toPy = {'error': 'error', 'info': 'info'}
3800     def __init__(self, error=None, info=None):
3801         '''
3802         error : Error
3803         info : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
3804         '''
3805         self.error = Error.from_json(error) if error else None
3806         self.info = [NetworkConfig.from_json(o) for o in info or []]
3807
3808
3809
3810 class MachineNetworkConfigResults(Type):
3811     _toSchema = {'results': 'results'}
3812     _toPy = {'results': 'results'}
3813     def __init__(self, results=None):
3814         '''
3815         results : typing.Sequence<+T_co>[~MachineNetworkConfigResult]<~MachineNetworkConfigResult>
3816         '''
3817         self.results = [MachineNetworkConfigResult.from_json(o) for o in results or []]
3818
3819
3820
3821 class MachinePortRange(Type):
3822     _toSchema = {'port_range': 'port-range', 'relation_tag': 'relation-tag', 'unit_tag': 'unit-tag'}
3823     _toPy = {'port-range': 'port_range', 'relation-tag': 'relation_tag', 'unit-tag': 'unit_tag'}
3824     def __init__(self, port_range=None, relation_tag=None, unit_tag=None):
3825         '''
3826         port_range : PortRange
3827         relation_tag : str
3828         unit_tag : str
3829         '''
3830         self.port_range = PortRange.from_json(port_range) if port_range else None
3831         self.relation_tag = relation_tag
3832         self.unit_tag = unit_tag
3833
3834
3835
3836 class MachinePorts(Type):
3837     _toSchema = {'machine_tag': 'machine-tag', 'subnet_tag': 'subnet-tag'}
3838     _toPy = {'machine-tag': 'machine_tag', 'subnet-tag': 'subnet_tag'}
3839     def __init__(self, machine_tag=None, subnet_tag=None):
3840         '''
3841         machine_tag : str
3842         subnet_tag : str
3843         '''
3844         self.machine_tag = machine_tag
3845         self.subnet_tag = subnet_tag
3846
3847
3848
3849 class MachinePortsParams(Type):
3850     _toSchema = {'params': 'params'}
3851     _toPy = {'params': 'params'}
3852     def __init__(self, params=None):
3853         '''
3854         params : typing.Sequence<+T_co>[~MachinePorts]<~MachinePorts>
3855         '''
3856         self.params = [MachinePorts.from_json(o) for o in params or []]
3857
3858
3859
3860 class MachinePortsResult(Type):
3861     _toSchema = {'error': 'error', 'ports': 'ports'}
3862     _toPy = {'error': 'error', 'ports': 'ports'}
3863     def __init__(self, error=None, ports=None):
3864         '''
3865         error : Error
3866         ports : typing.Sequence<+T_co>[~MachinePortRange]<~MachinePortRange>
3867         '''
3868         self.error = Error.from_json(error) if error else None
3869         self.ports = [MachinePortRange.from_json(o) for o in ports or []]
3870
3871
3872
3873 class MachinePortsResults(Type):
3874     _toSchema = {'results': 'results'}
3875     _toPy = {'results': 'results'}
3876     def __init__(self, results=None):
3877         '''
3878         results : typing.Sequence<+T_co>[~MachinePortsResult]<~MachinePortsResult>
3879         '''
3880         self.results = [MachinePortsResult.from_json(o) for o in results or []]
3881
3882
3883
3884 class MachineStatus(Type):
3885     _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'}
3886     _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'}
3887     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):
3888         '''
3889         agent_status : DetailedStatus
3890         containers : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
3891         dns_name : str
3892         hardware : str
3893         has_vote : bool
3894         id_ : str
3895         instance_id : str
3896         instance_status : DetailedStatus
3897         ip_addresses : typing.Sequence<+T_co>[str]
3898         jobs : typing.Sequence<+T_co>[str]
3899         series : str
3900         wants_vote : bool
3901         '''
3902         self.agent_status = DetailedStatus.from_json(agent_status) if agent_status else None
3903         self.containers = containers
3904         self.dns_name = dns_name
3905         self.hardware = hardware
3906         self.has_vote = has_vote
3907         self.id_ = id_
3908         self.instance_id = instance_id
3909         self.instance_status = DetailedStatus.from_json(instance_status) if instance_status else None
3910         self.ip_addresses = ip_addresses
3911         self.jobs = jobs
3912         self.series = series
3913         self.wants_vote = wants_vote
3914
3915
3916
3917 class MachineStorageId(Type):
3918     _toSchema = {'attachment_tag': 'attachment-tag', 'machine_tag': 'machine-tag'}
3919     _toPy = {'attachment-tag': 'attachment_tag', 'machine-tag': 'machine_tag'}
3920     def __init__(self, attachment_tag=None, machine_tag=None):
3921         '''
3922         attachment_tag : str
3923         machine_tag : str
3924         '''
3925         self.attachment_tag = attachment_tag
3926         self.machine_tag = machine_tag
3927
3928
3929
3930 class MachineStorageIds(Type):
3931     _toSchema = {'ids': 'ids'}
3932     _toPy = {'ids': 'ids'}
3933     def __init__(self, ids=None):
3934         '''
3935         ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
3936         '''
3937         self.ids = [MachineStorageId.from_json(o) for o in ids or []]
3938
3939
3940
3941 class MachineStorageIdsWatchResult(Type):
3942     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
3943     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
3944     def __init__(self, changes=None, error=None, watcher_id=None):
3945         '''
3946         changes : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
3947         error : Error
3948         watcher_id : str
3949         '''
3950         self.changes = [MachineStorageId.from_json(o) for o in changes or []]
3951         self.error = Error.from_json(error) if error else None
3952         self.watcher_id = watcher_id
3953
3954
3955
3956 class MachineStorageIdsWatchResults(Type):
3957     _toSchema = {'results': 'results'}
3958     _toPy = {'results': 'results'}
3959     def __init__(self, results=None):
3960         '''
3961         results : typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
3962         '''
3963         self.results = [MachineStorageIdsWatchResult.from_json(o) for o in results or []]
3964
3965
3966
3967 class MapResult(Type):
3968     _toSchema = {'error': 'error', 'result': 'result'}
3969     _toPy = {'error': 'error', 'result': 'result'}
3970     def __init__(self, error=None, result=None):
3971         '''
3972         error : Error
3973         result : typing.Mapping<~KT, +VT_co>[str, typing.Any]
3974         '''
3975         self.error = Error.from_json(error) if error else None
3976         self.result = result
3977
3978
3979
3980 class MapResults(Type):
3981     _toSchema = {'results': 'results'}
3982     _toPy = {'results': 'results'}
3983     def __init__(self, results=None):
3984         '''
3985         results : typing.Sequence<+T_co>[~MapResult]<~MapResult>
3986         '''
3987         self.results = [MapResult.from_json(o) for o in results or []]
3988
3989
3990
3991 class MasterMigrationStatus(Type):
3992     _toSchema = {'migration_id': 'migration-id', 'phase': 'phase', 'phase_changed_time': 'phase-changed-time', 'spec': 'spec'}
3993     _toPy = {'migration-id': 'migration_id', 'phase': 'phase', 'phase-changed-time': 'phase_changed_time', 'spec': 'spec'}
3994     def __init__(self, migration_id=None, phase=None, phase_changed_time=None, spec=None):
3995         '''
3996         migration_id : str
3997         phase : str
3998         phase_changed_time : str
3999         spec : MigrationSpec
4000         '''
4001         self.migration_id = migration_id
4002         self.phase = phase
4003         self.phase_changed_time = phase_changed_time
4004         self.spec = MigrationSpec.from_json(spec) if spec else None
4005
4006
4007
4008 class Member(Type):
4009     _toSchema = {'address': 'Address', 'arbiter': 'Arbiter', 'buildindexes': 'BuildIndexes', 'hidden': 'Hidden', 'id_': 'Id', 'priority': 'Priority', 'slavedelay': 'SlaveDelay', 'tags': 'Tags', 'votes': 'Votes'}
4010     _toPy = {'Address': 'address', 'Arbiter': 'arbiter', 'BuildIndexes': 'buildindexes', 'Hidden': 'hidden', 'Id': 'id_', 'Priority': 'priority', 'SlaveDelay': 'slavedelay', 'Tags': 'tags', 'Votes': 'votes'}
4011     def __init__(self, address=None, arbiter=None, buildindexes=None, hidden=None, id_=None, priority=None, slavedelay=None, tags=None, votes=None):
4012         '''
4013         address : str
4014         arbiter : bool
4015         buildindexes : bool
4016         hidden : bool
4017         id_ : int
4018         priority : float
4019         slavedelay : int
4020         tags : typing.Mapping<~KT, +VT_co>[str, str]
4021         votes : int
4022         '''
4023         self.address = address
4024         self.arbiter = arbiter
4025         self.buildindexes = buildindexes
4026         self.hidden = hidden
4027         self.id_ = id_
4028         self.priority = priority
4029         self.slavedelay = slavedelay
4030         self.tags = tags
4031         self.votes = votes
4032
4033
4034
4035 class MergeLeadershipSettingsBulkParams(Type):
4036     _toSchema = {'params': 'params'}
4037     _toPy = {'params': 'params'}
4038     def __init__(self, params=None):
4039         '''
4040         params : typing.Sequence<+T_co>[~MergeLeadershipSettingsParam]<~MergeLeadershipSettingsParam>
4041         '''
4042         self.params = [MergeLeadershipSettingsParam.from_json(o) for o in params or []]
4043
4044
4045
4046 class MergeLeadershipSettingsParam(Type):
4047     _toSchema = {'application_tag': 'application-tag', 'settings': 'settings'}
4048     _toPy = {'application-tag': 'application_tag', 'settings': 'settings'}
4049     def __init__(self, application_tag=None, settings=None):
4050         '''
4051         application_tag : str
4052         settings : typing.Mapping<~KT, +VT_co>[str, str]
4053         '''
4054         self.application_tag = application_tag
4055         self.settings = settings
4056
4057
4058
4059 class MetadataImageIds(Type):
4060     _toSchema = {'image_ids': 'image-ids'}
4061     _toPy = {'image-ids': 'image_ids'}
4062     def __init__(self, image_ids=None):
4063         '''
4064         image_ids : typing.Sequence<+T_co>[str]
4065         '''
4066         self.image_ids = image_ids
4067
4068
4069
4070 class MetadataSaveParams(Type):
4071     _toSchema = {'metadata': 'metadata'}
4072     _toPy = {'metadata': 'metadata'}
4073     def __init__(self, metadata=None):
4074         '''
4075         metadata : typing.Sequence<+T_co>[~CloudImageMetadataList]<~CloudImageMetadataList>
4076         '''
4077         self.metadata = [CloudImageMetadataList.from_json(o) for o in metadata or []]
4078
4079
4080
4081 class MeterStatus(Type):
4082     _toSchema = {'color': 'color', 'message': 'message'}
4083     _toPy = {'color': 'color', 'message': 'message'}
4084     def __init__(self, color=None, message=None):
4085         '''
4086         color : str
4087         message : str
4088         '''
4089         self.color = color
4090         self.message = message
4091
4092
4093
4094 class MeterStatusParam(Type):
4095     _toSchema = {'code': 'code', 'info': 'info', 'tag': 'tag'}
4096     _toPy = {'code': 'code', 'info': 'info', 'tag': 'tag'}
4097     def __init__(self, code=None, info=None, tag=None):
4098         '''
4099         code : str
4100         info : str
4101         tag : str
4102         '''
4103         self.code = code
4104         self.info = info
4105         self.tag = tag
4106
4107
4108
4109 class MeterStatusParams(Type):
4110     _toSchema = {'statues': 'statues'}
4111     _toPy = {'statues': 'statues'}
4112     def __init__(self, statues=None):
4113         '''
4114         statues : typing.Sequence<+T_co>[~MeterStatusParam]<~MeterStatusParam>
4115         '''
4116         self.statues = [MeterStatusParam.from_json(o) for o in statues or []]
4117
4118
4119
4120 class MeterStatusResult(Type):
4121     _toSchema = {'code': 'code', 'error': 'error', 'info': 'info'}
4122     _toPy = {'code': 'code', 'error': 'error', 'info': 'info'}
4123     def __init__(self, code=None, error=None, info=None):
4124         '''
4125         code : str
4126         error : Error
4127         info : str
4128         '''
4129         self.code = code
4130         self.error = Error.from_json(error) if error else None
4131         self.info = info
4132
4133
4134
4135 class MeterStatusResults(Type):
4136     _toSchema = {'results': 'results'}
4137     _toPy = {'results': 'results'}
4138     def __init__(self, results=None):
4139         '''
4140         results : typing.Sequence<+T_co>[~MeterStatusResult]<~MeterStatusResult>
4141         '''
4142         self.results = [MeterStatusResult.from_json(o) for o in results or []]
4143
4144
4145
4146 class Metric(Type):
4147     _toSchema = {'key': 'key', 'time': 'time', 'value': 'value'}
4148     _toPy = {'key': 'key', 'time': 'time', 'value': 'value'}
4149     def __init__(self, key=None, time=None, value=None):
4150         '''
4151         key : str
4152         time : str
4153         value : str
4154         '''
4155         self.key = key
4156         self.time = time
4157         self.value = value
4158
4159
4160
4161 class MetricBatch(Type):
4162     _toSchema = {'charm_url': 'charm-url', 'created': 'created', 'metrics': 'metrics', 'uuid': 'uuid'}
4163     _toPy = {'charm-url': 'charm_url', 'created': 'created', 'metrics': 'metrics', 'uuid': 'uuid'}
4164     def __init__(self, charm_url=None, created=None, metrics=None, uuid=None):
4165         '''
4166         charm_url : str
4167         created : str
4168         metrics : typing.Sequence<+T_co>[~Metric]<~Metric>
4169         uuid : str
4170         '''
4171         self.charm_url = charm_url
4172         self.created = created
4173         self.metrics = [Metric.from_json(o) for o in metrics or []]
4174         self.uuid = uuid
4175
4176
4177
4178 class MetricBatchParam(Type):
4179     _toSchema = {'batch': 'batch', 'tag': 'tag'}
4180     _toPy = {'batch': 'batch', 'tag': 'tag'}
4181     def __init__(self, batch=None, tag=None):
4182         '''
4183         batch : MetricBatch
4184         tag : str
4185         '''
4186         self.batch = MetricBatch.from_json(batch) if batch else None
4187         self.tag = tag
4188
4189
4190
4191 class MetricBatchParams(Type):
4192     _toSchema = {'batches': 'batches'}
4193     _toPy = {'batches': 'batches'}
4194     def __init__(self, batches=None):
4195         '''
4196         batches : typing.Sequence<+T_co>[~MetricBatchParam]<~MetricBatchParam>
4197         '''
4198         self.batches = [MetricBatchParam.from_json(o) for o in batches or []]
4199
4200
4201
4202 class MetricResult(Type):
4203     _toSchema = {'key': 'key', 'time': 'time', 'unit': 'unit', 'value': 'value'}
4204     _toPy = {'key': 'key', 'time': 'time', 'unit': 'unit', 'value': 'value'}
4205     def __init__(self, key=None, time=None, unit=None, value=None):
4206         '''
4207         key : str
4208         time : str
4209         unit : str
4210         value : str
4211         '''
4212         self.key = key
4213         self.time = time
4214         self.unit = unit
4215         self.value = value
4216
4217
4218
4219 class MetricResults(Type):
4220     _toSchema = {'results': 'results'}
4221     _toPy = {'results': 'results'}
4222     def __init__(self, results=None):
4223         '''
4224         results : typing.Sequence<+T_co>[~EntityMetrics]<~EntityMetrics>
4225         '''
4226         self.results = [EntityMetrics.from_json(o) for o in results or []]
4227
4228
4229
4230 class MigrationModelInfo(Type):
4231     _toSchema = {'agent_version': 'agent-version', 'name': 'name', 'owner_tag': 'owner-tag', 'uuid': 'uuid'}
4232     _toPy = {'agent-version': 'agent_version', 'name': 'name', 'owner-tag': 'owner_tag', 'uuid': 'uuid'}
4233     def __init__(self, agent_version=None, name=None, owner_tag=None, uuid=None):
4234         '''
4235         agent_version : Number
4236         name : str
4237         owner_tag : str
4238         uuid : str
4239         '''
4240         self.agent_version = Number.from_json(agent_version) if agent_version else None
4241         self.name = name
4242         self.owner_tag = owner_tag
4243         self.uuid = uuid
4244
4245
4246
4247 class MigrationSpec(Type):
4248     _toSchema = {'external_control': 'external-control', 'model_tag': 'model-tag', 'skip_initial_prechecks': 'skip-initial-prechecks', 'target_info': 'target-info'}
4249     _toPy = {'external-control': 'external_control', 'model-tag': 'model_tag', 'skip-initial-prechecks': 'skip_initial_prechecks', 'target-info': 'target_info'}
4250     def __init__(self, external_control=None, model_tag=None, skip_initial_prechecks=None, target_info=None):
4251         '''
4252         external_control : bool
4253         model_tag : str
4254         skip_initial_prechecks : bool
4255         target_info : MigrationTargetInfo
4256         '''
4257         self.external_control = external_control
4258         self.model_tag = model_tag
4259         self.skip_initial_prechecks = skip_initial_prechecks
4260         self.target_info = MigrationTargetInfo.from_json(target_info) if target_info else None
4261
4262
4263
4264 class MigrationStatus(Type):
4265     _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'}
4266     _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'}
4267     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):
4268         '''
4269         attempt : int
4270         external_control : bool
4271         migration_id : str
4272         phase : str
4273         source_api_addrs : typing.Sequence<+T_co>[str]
4274         source_ca_cert : str
4275         target_api_addrs : typing.Sequence<+T_co>[str]
4276         target_ca_cert : str
4277         '''
4278         self.attempt = attempt
4279         self.external_control = external_control
4280         self.migration_id = migration_id
4281         self.phase = phase
4282         self.source_api_addrs = source_api_addrs
4283         self.source_ca_cert = source_ca_cert
4284         self.target_api_addrs = target_api_addrs
4285         self.target_ca_cert = target_ca_cert
4286
4287
4288
4289 class MigrationTargetInfo(Type):
4290     _toSchema = {'addrs': 'addrs', 'auth_tag': 'auth-tag', 'ca_cert': 'ca-cert', 'controller_tag': 'controller-tag', 'macaroons': 'macaroons', 'password': 'password'}
4291     _toPy = {'addrs': 'addrs', 'auth-tag': 'auth_tag', 'ca-cert': 'ca_cert', 'controller-tag': 'controller_tag', 'macaroons': 'macaroons', 'password': 'password'}
4292     def __init__(self, addrs=None, auth_tag=None, ca_cert=None, controller_tag=None, macaroons=None, password=None):
4293         '''
4294         addrs : typing.Sequence<+T_co>[str]
4295         auth_tag : str
4296         ca_cert : str
4297         controller_tag : str
4298         macaroons : str
4299         password : str
4300         '''
4301         self.addrs = addrs
4302         self.auth_tag = auth_tag
4303         self.ca_cert = ca_cert
4304         self.controller_tag = controller_tag
4305         self.macaroons = macaroons
4306         self.password = password
4307
4308
4309
4310 class MinionReport(Type):
4311     _toSchema = {'migration_id': 'migration-id', 'phase': 'phase', 'success': 'success'}
4312     _toPy = {'migration-id': 'migration_id', 'phase': 'phase', 'success': 'success'}
4313     def __init__(self, migration_id=None, phase=None, success=None):
4314         '''
4315         migration_id : str
4316         phase : str
4317         success : bool
4318         '''
4319         self.migration_id = migration_id
4320         self.phase = phase
4321         self.success = success
4322
4323
4324
4325 class MinionReports(Type):
4326     _toSchema = {'failed': 'failed', 'migration_id': 'migration-id', 'phase': 'phase', 'success_count': 'success-count', 'unknown_count': 'unknown-count', 'unknown_sample': 'unknown-sample'}
4327     _toPy = {'failed': 'failed', 'migration-id': 'migration_id', 'phase': 'phase', 'success-count': 'success_count', 'unknown-count': 'unknown_count', 'unknown-sample': 'unknown_sample'}
4328     def __init__(self, failed=None, migration_id=None, phase=None, success_count=None, unknown_count=None, unknown_sample=None):
4329         '''
4330         failed : typing.Sequence<+T_co>[str]
4331         migration_id : str
4332         phase : str
4333         success_count : int
4334         unknown_count : int
4335         unknown_sample : typing.Sequence<+T_co>[str]
4336         '''
4337         self.failed = failed
4338         self.migration_id = migration_id
4339         self.phase = phase
4340         self.success_count = success_count
4341         self.unknown_count = unknown_count
4342         self.unknown_sample = unknown_sample
4343
4344
4345
4346 class Model(Type):
4347     _toSchema = {'name': 'name', 'owner_tag': 'owner-tag', 'uuid': 'uuid'}
4348     _toPy = {'name': 'name', 'owner-tag': 'owner_tag', 'uuid': 'uuid'}
4349     def __init__(self, name=None, owner_tag=None, uuid=None):
4350         '''
4351         name : str
4352         owner_tag : str
4353         uuid : str
4354         '''
4355         self.name = name
4356         self.owner_tag = owner_tag
4357         self.uuid = uuid
4358
4359
4360
4361 class ModelArgs(Type):
4362     _toSchema = {'model_tag': 'model-tag'}
4363     _toPy = {'model-tag': 'model_tag'}
4364     def __init__(self, model_tag=None):
4365         '''
4366         model_tag : str
4367         '''
4368         self.model_tag = model_tag
4369
4370
4371
4372 class ModelBlockInfo(Type):
4373     _toSchema = {'blocks': 'blocks', 'model_uuid': 'model-uuid', 'name': 'name', 'owner_tag': 'owner-tag'}
4374     _toPy = {'blocks': 'blocks', 'model-uuid': 'model_uuid', 'name': 'name', 'owner-tag': 'owner_tag'}
4375     def __init__(self, blocks=None, model_uuid=None, name=None, owner_tag=None):
4376         '''
4377         blocks : typing.Sequence<+T_co>[str]
4378         model_uuid : str
4379         name : str
4380         owner_tag : str
4381         '''
4382         self.blocks = blocks
4383         self.model_uuid = model_uuid
4384         self.name = name
4385         self.owner_tag = owner_tag
4386
4387
4388
4389 class ModelBlockInfoList(Type):
4390     _toSchema = {'models': 'models'}
4391     _toPy = {'models': 'models'}
4392     def __init__(self, models=None):
4393         '''
4394         models : typing.Sequence<+T_co>[~ModelBlockInfo]<~ModelBlockInfo>
4395         '''
4396         self.models = [ModelBlockInfo.from_json(o) for o in models or []]
4397
4398
4399
4400 class ModelConfigResult(Type):
4401     _toSchema = {'config': 'config'}
4402     _toPy = {'config': 'config'}
4403     def __init__(self, config=None):
4404         '''
4405         config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
4406         '''
4407         self.config = config
4408
4409
4410
4411 class ModelConfigResults(Type):
4412     _toSchema = {'config': 'config'}
4413     _toPy = {'config': 'config'}
4414     def __init__(self, config=None):
4415         '''
4416         config : typing.Mapping<~KT, +VT_co>[str, ~ConfigValue]<~ConfigValue>
4417         '''
4418         self.config = config
4419
4420
4421
4422 class ModelCreateArgs(Type):
4423     _toSchema = {'cloud_tag': 'cloud-tag', 'config': 'config', 'credential': 'credential', 'name': 'name', 'owner_tag': 'owner-tag', 'region': 'region'}
4424     _toPy = {'cloud-tag': 'cloud_tag', 'config': 'config', 'credential': 'credential', 'name': 'name', 'owner-tag': 'owner_tag', 'region': 'region'}
4425     def __init__(self, cloud_tag=None, config=None, credential=None, name=None, owner_tag=None, region=None):
4426         '''
4427         cloud_tag : str
4428         config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
4429         credential : str
4430         name : str
4431         owner_tag : str
4432         region : str
4433         '''
4434         self.cloud_tag = cloud_tag
4435         self.config = config
4436         self.credential = credential
4437         self.name = name
4438         self.owner_tag = owner_tag
4439         self.region = region
4440
4441
4442
4443 class ModelDefaultValues(Type):
4444     _toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'config': 'config'}
4445     _toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'config': 'config'}
4446     def __init__(self, cloud_region=None, cloud_tag=None, config=None):
4447         '''
4448         cloud_region : str
4449         cloud_tag : str
4450         config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
4451         '''
4452         self.cloud_region = cloud_region
4453         self.cloud_tag = cloud_tag
4454         self.config = config
4455
4456
4457
4458 class ModelDefaults(Type):
4459     _toSchema = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
4460     _toPy = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
4461     def __init__(self, controller=None, default=None, regions=None):
4462         '''
4463         controller : typing.Mapping<~KT, +VT_co>[str, typing.Any]
4464         default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
4465         regions : typing.Sequence<+T_co>[~RegionDefaults]<~RegionDefaults>
4466         '''
4467         self.controller = controller
4468         self.default = default
4469         self.regions = [RegionDefaults.from_json(o) for o in regions or []]
4470
4471
4472
4473 class ModelDefaultsResult(Type):
4474     _toSchema = {'config': 'config'}
4475     _toPy = {'config': 'config'}
4476     def __init__(self, config=None):
4477         '''
4478         config : typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
4479         '''
4480         self.config = config
4481
4482
4483
4484 class ModelInfo(Type):
4485     _toSchema = {'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', 'users': 'users', 'uuid': 'uuid'}
4486     _toPy = {'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', 'users': 'users', 'uuid': 'uuid'}
4487     def __init__(self, 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, users=None, uuid=None):
4488         '''
4489         cloud_credential_tag : str
4490         cloud_region : str
4491         cloud_tag : str
4492         controller_uuid : str
4493         default_series : str
4494         life : str
4495         machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
4496         migration : ModelMigrationStatus
4497         name : str
4498         owner_tag : str
4499         provider_type : str
4500         sla : ModelSLAInfo
4501         status : EntityStatus
4502         users : typing.Sequence<+T_co>[~ModelUserInfo]<~ModelUserInfo>
4503         uuid : str
4504         '''
4505         self.cloud_credential_tag = cloud_credential_tag
4506         self.cloud_region = cloud_region
4507         self.cloud_tag = cloud_tag
4508         self.controller_uuid = controller_uuid
4509         self.default_series = default_series
4510         self.life = life
4511         self.machines = [ModelMachineInfo.from_json(o) for o in machines or []]
4512         self.migration = ModelMigrationStatus.from_json(migration) if migration else None
4513         self.name = name
4514         self.owner_tag = owner_tag
4515         self.provider_type = provider_type
4516         self.sla = ModelSLAInfo.from_json(sla) if sla else None
4517         self.status = EntityStatus.from_json(status) if status else None
4518         self.users = [ModelUserInfo.from_json(o) for o in users or []]
4519         self.uuid = uuid
4520
4521
4522
4523 class ModelInfoResult(Type):
4524     _toSchema = {'error': 'error', 'result': 'result'}
4525     _toPy = {'error': 'error', 'result': 'result'}
4526     def __init__(self, error=None, result=None):
4527         '''
4528         error : Error
4529         result : ModelInfo
4530         '''
4531         self.error = Error.from_json(error) if error else None
4532         self.result = ModelInfo.from_json(result) if result else None
4533
4534
4535
4536 class ModelInfoResults(Type):
4537     _toSchema = {'results': 'results'}
4538     _toPy = {'results': 'results'}
4539     def __init__(self, results=None):
4540         '''
4541         results : typing.Sequence<+T_co>[~ModelInfoResult]<~ModelInfoResult>
4542         '''
4543         self.results = [ModelInfoResult.from_json(o) for o in results or []]
4544
4545
4546
4547 class ModelInstanceTypesConstraint(Type):
4548     _toSchema = {'value': 'value'}
4549     _toPy = {'value': 'value'}
4550     def __init__(self, value=None):
4551         '''
4552         value : Value
4553         '''
4554         self.value = Value.from_json(value) if value else None
4555
4556
4557
4558 class ModelInstanceTypesConstraints(Type):
4559     _toSchema = {'constraints': 'constraints'}
4560     _toPy = {'constraints': 'constraints'}
4561     def __init__(self, constraints=None):
4562         '''
4563         constraints : typing.Sequence<+T_co>[~ModelInstanceTypesConstraint]<~ModelInstanceTypesConstraint>
4564         '''
4565         self.constraints = [ModelInstanceTypesConstraint.from_json(o) for o in constraints or []]
4566
4567
4568
4569 class ModelMachineInfo(Type):
4570     _toSchema = {'hardware': 'hardware', 'has_vote': 'has-vote', 'id_': 'id', 'instance_id': 'instance-id', 'status': 'status', 'wants_vote': 'wants-vote'}
4571     _toPy = {'hardware': 'hardware', 'has-vote': 'has_vote', 'id': 'id_', 'instance-id': 'instance_id', 'status': 'status', 'wants-vote': 'wants_vote'}
4572     def __init__(self, hardware=None, has_vote=None, id_=None, instance_id=None, status=None, wants_vote=None):
4573         '''
4574         hardware : MachineHardware
4575         has_vote : bool
4576         id_ : str
4577         instance_id : str
4578         status : str
4579         wants_vote : bool
4580         '''
4581         self.hardware = MachineHardware.from_json(hardware) if hardware else None
4582         self.has_vote = has_vote
4583         self.id_ = id_
4584         self.instance_id = instance_id
4585         self.status = status
4586         self.wants_vote = wants_vote
4587
4588
4589
4590 class ModelMigrationStatus(Type):
4591     _toSchema = {'end': 'end', 'start': 'start', 'status': 'status'}
4592     _toPy = {'end': 'end', 'start': 'start', 'status': 'status'}
4593     def __init__(self, end=None, start=None, status=None):
4594         '''
4595         end : str
4596         start : str
4597         status : str
4598         '''
4599         self.end = end
4600         self.start = start
4601         self.status = status
4602
4603
4604
4605 class ModelResult(Type):
4606     _toSchema = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
4607     _toPy = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
4608     def __init__(self, error=None, name=None, uuid=None):
4609         '''
4610         error : Error
4611         name : str
4612         uuid : str
4613         '''
4614         self.error = Error.from_json(error) if error else None
4615         self.name = name
4616         self.uuid = uuid
4617
4618
4619
4620 class ModelSLA(Type):
4621     _toSchema = {'creds': 'creds', 'level': 'level'}
4622     _toPy = {'creds': 'creds', 'level': 'level'}
4623     def __init__(self, creds=None, level=None):
4624         '''
4625         creds : typing.Sequence<+T_co>[int]
4626         level : str
4627         '''
4628         self.creds = creds
4629         self.level = level
4630
4631
4632
4633 class ModelSLAInfo(Type):
4634     _toSchema = {'level': 'level', 'owner': 'owner'}
4635     _toPy = {'level': 'level', 'owner': 'owner'}
4636     def __init__(self, level=None, owner=None):
4637         '''
4638         level : str
4639         owner : str
4640         '''
4641         self.level = level
4642         self.owner = owner
4643
4644
4645
4646 class ModelSet(Type):
4647     _toSchema = {'config': 'config'}
4648     _toPy = {'config': 'config'}
4649     def __init__(self, config=None):
4650         '''
4651         config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
4652         '''
4653         self.config = config
4654
4655
4656
4657 class ModelStatus(Type):
4658     _toSchema = {'application_count': 'application-count', 'hosted_machine_count': 'hosted-machine-count', 'life': 'life', 'machines': 'machines', 'model_tag': 'model-tag', 'owner_tag': 'owner-tag'}
4659     _toPy = {'application-count': 'application_count', 'hosted-machine-count': 'hosted_machine_count', 'life': 'life', 'machines': 'machines', 'model-tag': 'model_tag', 'owner-tag': 'owner_tag'}
4660     def __init__(self, application_count=None, hosted_machine_count=None, life=None, machines=None, model_tag=None, owner_tag=None):
4661         '''
4662         application_count : int
4663         hosted_machine_count : int
4664         life : str
4665         machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
4666         model_tag : str
4667         owner_tag : str
4668         '''
4669         self.application_count = application_count
4670         self.hosted_machine_count = hosted_machine_count
4671         self.life = life
4672         self.machines = [ModelMachineInfo.from_json(o) for o in machines or []]
4673         self.model_tag = model_tag
4674         self.owner_tag = owner_tag
4675
4676
4677
4678 class ModelStatusInfo(Type):
4679     _toSchema = {'available_version': 'available-version', 'cloud_tag': 'cloud-tag', 'meter_status': 'meter-status', 'model_status': 'model-status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'version': 'version'}
4680     _toPy = {'available-version': 'available_version', 'cloud-tag': 'cloud_tag', 'meter-status': 'meter_status', 'model-status': 'model_status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'version': 'version'}
4681     def __init__(self, available_version=None, cloud_tag=None, meter_status=None, model_status=None, name=None, region=None, sla=None, version=None):
4682         '''
4683         available_version : str
4684         cloud_tag : str
4685         meter_status : MeterStatus
4686         model_status : DetailedStatus
4687         name : str
4688         region : str
4689         sla : str
4690         version : str
4691         '''
4692         self.available_version = available_version
4693         self.cloud_tag = cloud_tag
4694         self.meter_status = MeterStatus.from_json(meter_status) if meter_status else None
4695         self.model_status = DetailedStatus.from_json(model_status) if model_status else None
4696         self.name = name
4697         self.region = region
4698         self.sla = sla
4699         self.version = version
4700
4701
4702
4703 class ModelStatusResults(Type):
4704     _toSchema = {'models': 'models'}
4705     _toPy = {'models': 'models'}
4706     def __init__(self, models=None):
4707         '''
4708         models : typing.Sequence<+T_co>[~ModelStatus]<~ModelStatus>
4709         '''
4710         self.models = [ModelStatus.from_json(o) for o in models or []]
4711
4712
4713
4714 class ModelTag(Type):
4715     _toSchema = {}
4716     _toPy = {}
4717     def __init__(self):
4718         '''
4719
4720         '''
4721         pass
4722
4723
4724
4725 class ModelUnset(Type):
4726     _toSchema = {'keys': 'keys'}
4727     _toPy = {'keys': 'keys'}
4728     def __init__(self, keys=None):
4729         '''
4730         keys : typing.Sequence<+T_co>[str]
4731         '''
4732         self.keys = keys
4733
4734
4735
4736 class ModelUnsetKeys(Type):
4737     _toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'keys': 'keys'}
4738     _toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'keys': 'keys'}
4739     def __init__(self, cloud_region=None, cloud_tag=None, keys=None):
4740         '''
4741         cloud_region : str
4742         cloud_tag : str
4743         keys : typing.Sequence<+T_co>[str]
4744         '''
4745         self.cloud_region = cloud_region
4746         self.cloud_tag = cloud_tag
4747         self.keys = keys
4748
4749
4750
4751 class ModelUserInfo(Type):
4752     _toSchema = {'access': 'access', 'display_name': 'display-name', 'last_connection': 'last-connection', 'user': 'user'}
4753     _toPy = {'access': 'access', 'display-name': 'display_name', 'last-connection': 'last_connection', 'user': 'user'}
4754     def __init__(self, access=None, display_name=None, last_connection=None, user=None):
4755         '''
4756         access : str
4757         display_name : str
4758         last_connection : str
4759         user : str
4760         '''
4761         self.access = access
4762         self.display_name = display_name
4763         self.last_connection = last_connection
4764         self.user = user
4765
4766
4767
4768 class ModelUserInfoResult(Type):
4769     _toSchema = {'error': 'error', 'result': 'result'}
4770     _toPy = {'error': 'error', 'result': 'result'}
4771     def __init__(self, error=None, result=None):
4772         '''
4773         error : Error
4774         result : ModelUserInfo
4775         '''
4776         self.error = Error.from_json(error) if error else None
4777         self.result = ModelUserInfo.from_json(result) if result else None
4778
4779
4780
4781 class ModelUserInfoResults(Type):
4782     _toSchema = {'results': 'results'}
4783     _toPy = {'results': 'results'}
4784     def __init__(self, results=None):
4785         '''
4786         results : typing.Sequence<+T_co>[~ModelUserInfoResult]<~ModelUserInfoResult>
4787         '''
4788         self.results = [ModelUserInfoResult.from_json(o) for o in results or []]
4789
4790
4791
4792 class ModifyControllerAccess(Type):
4793     _toSchema = {'access': 'access', 'action': 'action', 'user_tag': 'user-tag'}
4794     _toPy = {'access': 'access', 'action': 'action', 'user-tag': 'user_tag'}
4795     def __init__(self, access=None, action=None, user_tag=None):
4796         '''
4797         access : str
4798         action : str
4799         user_tag : str
4800         '''
4801         self.access = access
4802         self.action = action
4803         self.user_tag = user_tag
4804
4805
4806
4807 class ModifyControllerAccessRequest(Type):
4808     _toSchema = {'changes': 'changes'}
4809     _toPy = {'changes': 'changes'}
4810     def __init__(self, changes=None):
4811         '''
4812         changes : typing.Sequence<+T_co>[~ModifyControllerAccess]<~ModifyControllerAccess>
4813         '''
4814         self.changes = [ModifyControllerAccess.from_json(o) for o in changes or []]
4815
4816
4817
4818 class ModifyModelAccess(Type):
4819     _toSchema = {'access': 'access', 'action': 'action', 'model_tag': 'model-tag', 'user_tag': 'user-tag'}
4820     _toPy = {'access': 'access', 'action': 'action', 'model-tag': 'model_tag', 'user-tag': 'user_tag'}
4821     def __init__(self, access=None, action=None, model_tag=None, user_tag=None):
4822         '''
4823         access : str
4824         action : str
4825         model_tag : str
4826         user_tag : str
4827         '''
4828         self.access = access
4829         self.action = action
4830         self.model_tag = model_tag
4831         self.user_tag = user_tag
4832
4833
4834
4835 class ModifyModelAccessRequest(Type):
4836     _toSchema = {'changes': 'changes'}
4837     _toPy = {'changes': 'changes'}
4838     def __init__(self, changes=None):
4839         '''
4840         changes : typing.Sequence<+T_co>[~ModifyModelAccess]<~ModifyModelAccess>
4841         '''
4842         self.changes = [ModifyModelAccess.from_json(o) for o in changes or []]
4843
4844
4845
4846 class ModifyUserSSHKeys(Type):
4847     _toSchema = {'ssh_keys': 'ssh-keys', 'user': 'user'}
4848     _toPy = {'ssh-keys': 'ssh_keys', 'user': 'user'}
4849     def __init__(self, ssh_keys=None, user=None):
4850         '''
4851         ssh_keys : typing.Sequence<+T_co>[str]
4852         user : str
4853         '''
4854         self.ssh_keys = ssh_keys
4855         self.user = user
4856
4857
4858
4859 class MongoUpgradeResults(Type):
4860     _toSchema = {'ha_members': 'ha-members', 'master': 'master', 'rs_members': 'rs-members'}
4861     _toPy = {'ha-members': 'ha_members', 'master': 'master', 'rs-members': 'rs_members'}
4862     def __init__(self, ha_members=None, master=None, rs_members=None):
4863         '''
4864         ha_members : typing.Sequence<+T_co>[~HAMember]<~HAMember>
4865         master : HAMember
4866         rs_members : typing.Sequence<+T_co>[~Member]<~Member>
4867         '''
4868         self.ha_members = [HAMember.from_json(o) for o in ha_members or []]
4869         self.master = HAMember.from_json(master) if master else None
4870         self.rs_members = [Member.from_json(o) for o in rs_members or []]
4871
4872
4873
4874 class MongoVersion(Type):
4875     _toSchema = {'engine': 'engine', 'major': 'major', 'minor': 'minor', 'patch': 'patch'}
4876     _toPy = {'engine': 'engine', 'major': 'major', 'minor': 'minor', 'patch': 'patch'}
4877     def __init__(self, engine=None, major=None, minor=None, patch=None):
4878         '''
4879         engine : str
4880         major : int
4881         minor : int
4882         patch : str
4883         '''
4884         self.engine = engine
4885         self.major = major
4886         self.minor = minor
4887         self.patch = patch
4888
4889
4890
4891 class NetworkConfig(Type):
4892     _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'}
4893     _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'}
4894     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):
4895         '''
4896         address : str
4897         cidr : str
4898         config_type : str
4899         device_index : int
4900         disabled : bool
4901         dns_search_domains : typing.Sequence<+T_co>[str]
4902         dns_servers : typing.Sequence<+T_co>[str]
4903         gateway_address : str
4904         interface_name : str
4905         interface_type : str
4906         mac_address : str
4907         mtu : int
4908         no_auto_start : bool
4909         parent_interface_name : str
4910         provider_address_id : str
4911         provider_id : str
4912         provider_space_id : str
4913         provider_subnet_id : str
4914         provider_vlan_id : str
4915         vlan_tag : int
4916         '''
4917         self.address = address
4918         self.cidr = cidr
4919         self.config_type = config_type
4920         self.device_index = device_index
4921         self.disabled = disabled
4922         self.dns_search_domains = dns_search_domains
4923         self.dns_servers = dns_servers
4924         self.gateway_address = gateway_address
4925         self.interface_name = interface_name
4926         self.interface_type = interface_type
4927         self.mac_address = mac_address
4928         self.mtu = mtu
4929         self.no_auto_start = no_auto_start
4930         self.parent_interface_name = parent_interface_name
4931         self.provider_address_id = provider_address_id
4932         self.provider_id = provider_id
4933         self.provider_space_id = provider_space_id
4934         self.provider_subnet_id = provider_subnet_id
4935         self.provider_vlan_id = provider_vlan_id
4936         self.vlan_tag = vlan_tag
4937
4938
4939
4940 class NetworkInterface(Type):
4941     _toSchema = {'dns_nameservers': 'dns-nameservers', 'gateway': 'gateway', 'ip_addresses': 'ip-addresses', 'is_up': 'is-up', 'mac_address': 'mac-address', 'space': 'space'}
4942     _toPy = {'dns-nameservers': 'dns_nameservers', 'gateway': 'gateway', 'ip-addresses': 'ip_addresses', 'is-up': 'is_up', 'mac-address': 'mac_address', 'space': 'space'}
4943     def __init__(self, dns_nameservers=None, gateway=None, ip_addresses=None, is_up=None, mac_address=None, space=None):
4944         '''
4945         dns_nameservers : typing.Sequence<+T_co>[str]
4946         gateway : str
4947         ip_addresses : typing.Sequence<+T_co>[str]
4948         is_up : bool
4949         mac_address : str
4950         space : str
4951         '''
4952         self.dns_nameservers = dns_nameservers
4953         self.gateway = gateway
4954         self.ip_addresses = ip_addresses
4955         self.is_up = is_up
4956         self.mac_address = mac_address
4957         self.space = space
4958
4959
4960
4961 class NetworkRoute(Type):
4962     _toSchema = {'destination_cidr': 'destination-cidr', 'gateway_ip': 'gateway-ip', 'metric': 'metric'}
4963     _toPy = {'destination-cidr': 'destination_cidr', 'gateway-ip': 'gateway_ip', 'metric': 'metric'}
4964     def __init__(self, destination_cidr=None, gateway_ip=None, metric=None):
4965         '''
4966         destination_cidr : str
4967         gateway_ip : str
4968         metric : int
4969         '''
4970         self.destination_cidr = destination_cidr
4971         self.gateway_ip = gateway_ip
4972         self.metric = metric
4973
4974
4975
4976 class NotifyWatchResult(Type):
4977     _toSchema = {'error': 'error', 'notifywatcherid': 'NotifyWatcherId'}
4978     _toPy = {'NotifyWatcherId': 'notifywatcherid', 'error': 'error'}
4979     def __init__(self, notifywatcherid=None, error=None):
4980         '''
4981         notifywatcherid : str
4982         error : Error
4983         '''
4984         self.notifywatcherid = notifywatcherid
4985         self.error = Error.from_json(error) if error else None
4986
4987
4988
4989 class NotifyWatchResults(Type):
4990     _toSchema = {'results': 'results'}
4991     _toPy = {'results': 'results'}
4992     def __init__(self, results=None):
4993         '''
4994         results : typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
4995         '''
4996         self.results = [NotifyWatchResult.from_json(o) for o in results or []]
4997
4998
4999
5000 class Number(Type):
5001     _toSchema = {'build': 'Build', 'major': 'Major', 'minor': 'Minor', 'patch': 'Patch', 'tag': 'Tag'}
5002     _toPy = {'Build': 'build', 'Major': 'major', 'Minor': 'minor', 'Patch': 'patch', 'Tag': 'tag'}
5003     def __init__(self, build=None, major=None, minor=None, patch=None, tag=None):
5004         '''
5005         build : int
5006         major : int
5007         minor : int
5008         patch : int
5009         tag : str
5010         '''
5011         self.build = build
5012         self.major = major
5013         self.minor = minor
5014         self.patch = patch
5015         self.tag = tag
5016
5017
5018
5019 class Payload(Type):
5020     _toSchema = {'class_': 'class', 'id_': 'id', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type_': 'type', 'unit': 'unit'}
5021     _toPy = {'class': 'class_', 'id': 'id_', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type': 'type_', 'unit': 'unit'}
5022     def __init__(self, class_=None, id_=None, labels=None, machine=None, status=None, type_=None, unit=None):
5023         '''
5024         class_ : str
5025         id_ : str
5026         labels : typing.Sequence<+T_co>[str]
5027         machine : str
5028         status : str
5029         type_ : str
5030         unit : str
5031         '''
5032         self.class_ = class_
5033         self.id_ = id_
5034         self.labels = labels
5035         self.machine = machine
5036         self.status = status
5037         self.type_ = type_
5038         self.unit = unit
5039
5040
5041
5042 class PayloadListArgs(Type):
5043     _toSchema = {'patterns': 'patterns'}
5044     _toPy = {'patterns': 'patterns'}
5045     def __init__(self, patterns=None):
5046         '''
5047         patterns : typing.Sequence<+T_co>[str]
5048         '''
5049         self.patterns = patterns
5050
5051
5052
5053 class PayloadListResults(Type):
5054     _toSchema = {'results': 'results'}
5055     _toPy = {'results': 'results'}
5056     def __init__(self, results=None):
5057         '''
5058         results : typing.Sequence<+T_co>[~Payload]<~Payload>
5059         '''
5060         self.results = [Payload.from_json(o) for o in results or []]
5061
5062
5063
5064 class PayloadResult(Type):
5065     _toSchema = {'entity': 'Entity', 'error': 'error', 'not_found': 'not-found', 'payload': 'payload'}
5066     _toPy = {'Entity': 'entity', 'error': 'error', 'not-found': 'not_found', 'payload': 'payload'}
5067     def __init__(self, entity=None, error=None, not_found=None, payload=None):
5068         '''
5069         entity : Entity
5070         error : Error
5071         not_found : bool
5072         payload : Payload
5073         '''
5074         self.entity = Entity.from_json(entity) if entity else None
5075         self.error = Error.from_json(error) if error else None
5076         self.not_found = not_found
5077         self.payload = Payload.from_json(payload) if payload else None
5078
5079
5080
5081 class PayloadResults(Type):
5082     _toSchema = {'results': 'results'}
5083     _toPy = {'results': 'results'}
5084     def __init__(self, results=None):
5085         '''
5086         results : typing.Sequence<+T_co>[~PayloadResult]<~PayloadResult>
5087         '''
5088         self.results = [PayloadResult.from_json(o) for o in results or []]
5089
5090
5091
5092 class PhaseResult(Type):
5093     _toSchema = {'error': 'error', 'phase': 'phase'}
5094     _toPy = {'error': 'error', 'phase': 'phase'}
5095     def __init__(self, error=None, phase=None):
5096         '''
5097         error : Error
5098         phase : str
5099         '''
5100         self.error = Error.from_json(error) if error else None
5101         self.phase = phase
5102
5103
5104
5105 class PhaseResults(Type):
5106     _toSchema = {'results': 'results'}
5107     _toPy = {'results': 'results'}
5108     def __init__(self, results=None):
5109         '''
5110         results : typing.Sequence<+T_co>[~PhaseResult]<~PhaseResult>
5111         '''
5112         self.results = [PhaseResult.from_json(o) for o in results or []]
5113
5114
5115
5116 class Placement(Type):
5117     _toSchema = {'directive': 'directive', 'scope': 'scope'}
5118     _toPy = {'directive': 'directive', 'scope': 'scope'}
5119     def __init__(self, directive=None, scope=None):
5120         '''
5121         directive : str
5122         scope : str
5123         '''
5124         self.directive = directive
5125         self.scope = scope
5126
5127
5128
5129 class PortRange(Type):
5130     _toSchema = {'from_port': 'from-port', 'protocol': 'protocol', 'to_port': 'to-port'}
5131     _toPy = {'from-port': 'from_port', 'protocol': 'protocol', 'to-port': 'to_port'}
5132     def __init__(self, from_port=None, protocol=None, to_port=None):
5133         '''
5134         from_port : int
5135         protocol : str
5136         to_port : int
5137         '''
5138         self.from_port = from_port
5139         self.protocol = protocol
5140         self.to_port = to_port
5141
5142
5143
5144 class PrivateAddress(Type):
5145     _toSchema = {'target': 'target'}
5146     _toPy = {'target': 'target'}
5147     def __init__(self, target=None):
5148         '''
5149         target : str
5150         '''
5151         self.target = target
5152
5153
5154
5155 class PrivateAddressResults(Type):
5156     _toSchema = {'private_address': 'private-address'}
5157     _toPy = {'private-address': 'private_address'}
5158     def __init__(self, private_address=None):
5159         '''
5160         private_address : str
5161         '''
5162         self.private_address = private_address
5163
5164
5165
5166 class ProviderInterfaceInfo(Type):
5167     _toSchema = {'interface_name': 'interface-name', 'mac_address': 'mac-address', 'provider_id': 'provider-id'}
5168     _toPy = {'interface-name': 'interface_name', 'mac-address': 'mac_address', 'provider-id': 'provider_id'}
5169     def __init__(self, interface_name=None, mac_address=None, provider_id=None):
5170         '''
5171         interface_name : str
5172         mac_address : str
5173         provider_id : str
5174         '''
5175         self.interface_name = interface_name
5176         self.mac_address = mac_address
5177         self.provider_id = provider_id
5178
5179
5180
5181 class ProviderInterfaceInfoResult(Type):
5182     _toSchema = {'error': 'error', 'interfaces': 'interfaces', 'machine_tag': 'machine-tag'}
5183     _toPy = {'error': 'error', 'interfaces': 'interfaces', 'machine-tag': 'machine_tag'}
5184     def __init__(self, error=None, interfaces=None, machine_tag=None):
5185         '''
5186         error : Error
5187         interfaces : typing.Sequence<+T_co>[~ProviderInterfaceInfo]<~ProviderInterfaceInfo>
5188         machine_tag : str
5189         '''
5190         self.error = Error.from_json(error) if error else None
5191         self.interfaces = [ProviderInterfaceInfo.from_json(o) for o in interfaces or []]
5192         self.machine_tag = machine_tag
5193
5194
5195
5196 class ProviderInterfaceInfoResults(Type):
5197     _toSchema = {'results': 'results'}
5198     _toPy = {'results': 'results'}
5199     def __init__(self, results=None):
5200         '''
5201         results : typing.Sequence<+T_co>[~ProviderInterfaceInfoResult]<~ProviderInterfaceInfoResult>
5202         '''
5203         self.results = [ProviderInterfaceInfoResult.from_json(o) for o in results or []]
5204
5205
5206
5207 class ProviderSpace(Type):
5208     _toSchema = {'error': 'error', 'name': 'name', 'provider_id': 'provider-id', 'subnets': 'subnets'}
5209     _toPy = {'error': 'error', 'name': 'name', 'provider-id': 'provider_id', 'subnets': 'subnets'}
5210     def __init__(self, error=None, name=None, provider_id=None, subnets=None):
5211         '''
5212         error : Error
5213         name : str
5214         provider_id : str
5215         subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
5216         '''
5217         self.error = Error.from_json(error) if error else None
5218         self.name = name
5219         self.provider_id = provider_id
5220         self.subnets = [Subnet.from_json(o) for o in subnets or []]
5221
5222
5223
5224 class ProvisioningInfo(Type):
5225     _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'}
5226     _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'}
5227     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):
5228         '''
5229         constraints : Value
5230         controller_config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
5231         endpoint_bindings : typing.Mapping<~KT, +VT_co>[str, str]
5232         image_metadata : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
5233         jobs : typing.Sequence<+T_co>[str]
5234         placement : str
5235         series : str
5236         subnets_to_zones : typing.Sequence<+T_co>[str]
5237         tags : typing.Mapping<~KT, +VT_co>[str, str]
5238         volumes : typing.Sequence<+T_co>[~VolumeParams]<~VolumeParams>
5239         '''
5240         self.constraints = Value.from_json(constraints) if constraints else None
5241         self.controller_config = controller_config
5242         self.endpoint_bindings = endpoint_bindings
5243         self.image_metadata = [CloudImageMetadata.from_json(o) for o in image_metadata or []]
5244         self.jobs = jobs
5245         self.placement = placement
5246         self.series = series
5247         self.subnets_to_zones = subnets_to_zones
5248         self.tags = tags
5249         self.volumes = [VolumeParams.from_json(o) for o in volumes or []]
5250
5251
5252
5253 class ProvisioningInfoResult(Type):
5254     _toSchema = {'error': 'error', 'result': 'result'}
5255     _toPy = {'error': 'error', 'result': 'result'}
5256     def __init__(self, error=None, result=None):
5257         '''
5258         error : Error
5259         result : ProvisioningInfo
5260         '''
5261         self.error = Error.from_json(error) if error else None
5262         self.result = ProvisioningInfo.from_json(result) if result else None
5263
5264
5265
5266 class ProvisioningInfoResults(Type):
5267     _toSchema = {'results': 'results'}
5268     _toPy = {'results': 'results'}
5269     def __init__(self, results=None):
5270         '''
5271         results : typing.Sequence<+T_co>[~ProvisioningInfoResult]<~ProvisioningInfoResult>
5272         '''
5273         self.results = [ProvisioningInfoResult.from_json(o) for o in results or []]
5274
5275
5276
5277 class ProvisioningScriptParams(Type):
5278     _toSchema = {'data_dir': 'data-dir', 'disable_package_commands': 'disable-package-commands', 'machine_id': 'machine-id', 'nonce': 'nonce'}
5279     _toPy = {'data-dir': 'data_dir', 'disable-package-commands': 'disable_package_commands', 'machine-id': 'machine_id', 'nonce': 'nonce'}
5280     def __init__(self, data_dir=None, disable_package_commands=None, machine_id=None, nonce=None):
5281         '''
5282         data_dir : str
5283         disable_package_commands : bool
5284         machine_id : str
5285         nonce : str
5286         '''
5287         self.data_dir = data_dir
5288         self.disable_package_commands = disable_package_commands
5289         self.machine_id = machine_id
5290         self.nonce = nonce
5291
5292
5293
5294 class ProvisioningScriptResult(Type):
5295     _toSchema = {'script': 'script'}
5296     _toPy = {'script': 'script'}
5297     def __init__(self, script=None):
5298         '''
5299         script : str
5300         '''
5301         self.script = script
5302
5303
5304
5305 class ProxyConfig(Type):
5306     _toSchema = {'ftp': 'ftp', 'http': 'http', 'https': 'https', 'no_proxy': 'no-proxy'}
5307     _toPy = {'ftp': 'ftp', 'http': 'http', 'https': 'https', 'no-proxy': 'no_proxy'}
5308     def __init__(self, ftp=None, http=None, https=None, no_proxy=None):
5309         '''
5310         ftp : str
5311         http : str
5312         https : str
5313         no_proxy : str
5314         '''
5315         self.ftp = ftp
5316         self.http = http
5317         self.https = https
5318         self.no_proxy = no_proxy
5319
5320
5321
5322 class ProxyConfigResult(Type):
5323     _toSchema = {'apt_proxy_settings': 'apt-proxy-settings', 'error': 'error', 'proxy_settings': 'proxy-settings'}
5324     _toPy = {'apt-proxy-settings': 'apt_proxy_settings', 'error': 'error', 'proxy-settings': 'proxy_settings'}
5325     def __init__(self, apt_proxy_settings=None, error=None, proxy_settings=None):
5326         '''
5327         apt_proxy_settings : ProxyConfig
5328         error : Error
5329         proxy_settings : ProxyConfig
5330         '''
5331         self.apt_proxy_settings = ProxyConfig.from_json(apt_proxy_settings) if apt_proxy_settings else None
5332         self.error = Error.from_json(error) if error else None
5333         self.proxy_settings = ProxyConfig.from_json(proxy_settings) if proxy_settings else None
5334
5335
5336
5337 class ProxyConfigResults(Type):
5338     _toSchema = {'results': 'results'}
5339     _toPy = {'results': 'results'}
5340     def __init__(self, results=None):
5341         '''
5342         results : typing.Sequence<+T_co>[~ProxyConfigResult]<~ProxyConfigResult>
5343         '''
5344         self.results = [ProxyConfigResult.from_json(o) for o in results or []]
5345
5346
5347
5348 class PublicAddress(Type):
5349     _toSchema = {'target': 'target'}
5350     _toPy = {'target': 'target'}
5351     def __init__(self, target=None):
5352         '''
5353         target : str
5354         '''
5355         self.target = target
5356
5357
5358
5359 class PublicAddressResults(Type):
5360     _toSchema = {'public_address': 'public-address'}
5361     _toPy = {'public-address': 'public_address'}
5362     def __init__(self, public_address=None):
5363         '''
5364         public_address : str
5365         '''
5366         self.public_address = public_address
5367
5368
5369
5370 class RebootActionResult(Type):
5371     _toSchema = {'error': 'error', 'result': 'result'}
5372     _toPy = {'error': 'error', 'result': 'result'}
5373     def __init__(self, error=None, result=None):
5374         '''
5375         error : Error
5376         result : str
5377         '''
5378         self.error = Error.from_json(error) if error else None
5379         self.result = result
5380
5381
5382
5383 class RebootActionResults(Type):
5384     _toSchema = {'results': 'results'}
5385     _toPy = {'results': 'results'}
5386     def __init__(self, results=None):
5387         '''
5388         results : typing.Sequence<+T_co>[~RebootActionResult]<~RebootActionResult>
5389         '''
5390         self.results = [RebootActionResult.from_json(o) for o in results or []]
5391
5392
5393
5394 class RegionDefaults(Type):
5395     _toSchema = {'region_name': 'region-name', 'value': 'value'}
5396     _toPy = {'region-name': 'region_name', 'value': 'value'}
5397     def __init__(self, region_name=None, value=None):
5398         '''
5399         region_name : str
5400         value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
5401         '''
5402         self.region_name = region_name
5403         self.value = value
5404
5405
5406
5407 class RelationChange(Type):
5408     _toSchema = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id_': 'id', 'life': 'life'}
5409     _toPy = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id': 'id_', 'life': 'life'}
5410     def __init__(self, changedunits=None, departedunits=None, id_=None, life=None):
5411         '''
5412         changedunits : typing.Mapping<~KT, +VT_co>[str, ~RelationUnitChange]<~RelationUnitChange>
5413         departedunits : typing.Sequence<+T_co>[str]
5414         id_ : int
5415         life : str
5416         '''
5417         self.changedunits = changedunits
5418         self.departedunits = departedunits
5419         self.id_ = id_
5420         self.life = life
5421
5422
5423
5424 class RelationIds(Type):
5425     _toSchema = {'relation_ids': 'relation-ids'}
5426     _toPy = {'relation-ids': 'relation_ids'}
5427     def __init__(self, relation_ids=None):
5428         '''
5429         relation_ids : typing.Sequence<+T_co>[int]
5430         '''
5431         self.relation_ids = relation_ids
5432
5433
5434
5435 class RelationResult(Type):
5436     _toSchema = {'endpoint': 'endpoint', 'error': 'error', 'id_': 'id', 'key': 'key', 'life': 'life'}
5437     _toPy = {'endpoint': 'endpoint', 'error': 'error', 'id': 'id_', 'key': 'key', 'life': 'life'}
5438     def __init__(self, endpoint=None, error=None, id_=None, key=None, life=None):
5439         '''
5440         endpoint : Endpoint
5441         error : Error
5442         id_ : int
5443         key : str
5444         life : str
5445         '''
5446         self.endpoint = Endpoint.from_json(endpoint) if endpoint else None
5447         self.error = Error.from_json(error) if error else None
5448         self.id_ = id_
5449         self.key = key
5450         self.life = life
5451
5452
5453
5454 class RelationResults(Type):
5455     _toSchema = {'results': 'results'}
5456     _toPy = {'results': 'results'}
5457     def __init__(self, results=None):
5458         '''
5459         results : typing.Sequence<+T_co>[~RelationResult]<~RelationResult>
5460         '''
5461         self.results = [RelationResult.from_json(o) for o in results or []]
5462
5463
5464
5465 class RelationStatus(Type):
5466     _toSchema = {'endpoints': 'endpoints', 'id_': 'id', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
5467     _toPy = {'endpoints': 'endpoints', 'id': 'id_', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
5468     def __init__(self, endpoints=None, id_=None, interface=None, key=None, scope=None):
5469         '''
5470         endpoints : typing.Sequence<+T_co>[~EndpointStatus]<~EndpointStatus>
5471         id_ : int
5472         interface : str
5473         key : str
5474         scope : str
5475         '''
5476         self.endpoints = [EndpointStatus.from_json(o) for o in endpoints or []]
5477         self.id_ = id_
5478         self.interface = interface
5479         self.key = key
5480         self.scope = scope
5481
5482
5483
5484 class RelationUnit(Type):
5485     _toSchema = {'relation': 'relation', 'unit': 'unit'}
5486     _toPy = {'relation': 'relation', 'unit': 'unit'}
5487     def __init__(self, relation=None, unit=None):
5488         '''
5489         relation : str
5490         unit : str
5491         '''
5492         self.relation = relation
5493         self.unit = unit
5494
5495
5496
5497 class RelationUnitChange(Type):
5498     _toSchema = {'settings': 'settings'}
5499     _toPy = {'settings': 'settings'}
5500     def __init__(self, settings=None):
5501         '''
5502         settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
5503         '''
5504         self.settings = settings
5505
5506
5507
5508 class RelationUnitPair(Type):
5509     _toSchema = {'local_unit': 'local-unit', 'relation': 'relation', 'remote_unit': 'remote-unit'}
5510     _toPy = {'local-unit': 'local_unit', 'relation': 'relation', 'remote-unit': 'remote_unit'}
5511     def __init__(self, local_unit=None, relation=None, remote_unit=None):
5512         '''
5513         local_unit : str
5514         relation : str
5515         remote_unit : str
5516         '''
5517         self.local_unit = local_unit
5518         self.relation = relation
5519         self.remote_unit = remote_unit
5520
5521
5522
5523 class RelationUnitPairs(Type):
5524     _toSchema = {'relation_unit_pairs': 'relation-unit-pairs'}
5525     _toPy = {'relation-unit-pairs': 'relation_unit_pairs'}
5526     def __init__(self, relation_unit_pairs=None):
5527         '''
5528         relation_unit_pairs : typing.Sequence<+T_co>[~RelationUnitPair]<~RelationUnitPair>
5529         '''
5530         self.relation_unit_pairs = [RelationUnitPair.from_json(o) for o in relation_unit_pairs or []]
5531
5532
5533
5534 class RelationUnitSettings(Type):
5535     _toSchema = {'relation': 'relation', 'settings': 'settings', 'unit': 'unit'}
5536     _toPy = {'relation': 'relation', 'settings': 'settings', 'unit': 'unit'}
5537     def __init__(self, relation=None, settings=None, unit=None):
5538         '''
5539         relation : str
5540         settings : typing.Mapping<~KT, +VT_co>[str, str]
5541         unit : str
5542         '''
5543         self.relation = relation
5544         self.settings = settings
5545         self.unit = unit
5546
5547
5548
5549 class RelationUnits(Type):
5550     _toSchema = {'relation_units': 'relation-units'}
5551     _toPy = {'relation-units': 'relation_units'}
5552     def __init__(self, relation_units=None):
5553         '''
5554         relation_units : typing.Sequence<+T_co>[~RelationUnit]<~RelationUnit>
5555         '''
5556         self.relation_units = [RelationUnit.from_json(o) for o in relation_units or []]
5557
5558
5559
5560 class RelationUnitsChange(Type):
5561     _toSchema = {'changed': 'changed', 'departed': 'departed'}
5562     _toPy = {'changed': 'changed', 'departed': 'departed'}
5563     def __init__(self, changed=None, departed=None):
5564         '''
5565         changed : typing.Mapping<~KT, +VT_co>[str, ~UnitSettings]<~UnitSettings>
5566         departed : typing.Sequence<+T_co>[str]
5567         '''
5568         self.changed = changed
5569         self.departed = departed
5570
5571
5572
5573 class RelationUnitsSettings(Type):
5574     _toSchema = {'relation_units': 'relation-units'}
5575     _toPy = {'relation-units': 'relation_units'}
5576     def __init__(self, relation_units=None):
5577         '''
5578         relation_units : typing.Sequence<+T_co>[~RelationUnitSettings]<~RelationUnitSettings>
5579         '''
5580         self.relation_units = [RelationUnitSettings.from_json(o) for o in relation_units or []]
5581
5582
5583
5584 class RelationUnitsWatchResult(Type):
5585     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
5586     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
5587     def __init__(self, changes=None, error=None, watcher_id=None):
5588         '''
5589         changes : RelationUnitsChange
5590         error : Error
5591         watcher_id : str
5592         '''
5593         self.changes = RelationUnitsChange.from_json(changes) if changes else None
5594         self.error = Error.from_json(error) if error else None
5595         self.watcher_id = watcher_id
5596
5597
5598
5599 class RelationUnitsWatchResults(Type):
5600     _toSchema = {'results': 'results'}
5601     _toPy = {'results': 'results'}
5602     def __init__(self, results=None):
5603         '''
5604         results : typing.Sequence<+T_co>[~RelationUnitsWatchResult]<~RelationUnitsWatchResult>
5605         '''
5606         self.results = [RelationUnitsWatchResult.from_json(o) for o in results or []]
5607
5608
5609
5610 class RemoteApplicationChange(Type):
5611     _toSchema = {'application_tag': 'application-tag', 'life': 'life', 'relations': 'relations'}
5612     _toPy = {'application-tag': 'application_tag', 'life': 'life', 'relations': 'relations'}
5613     def __init__(self, application_tag=None, life=None, relations=None):
5614         '''
5615         application_tag : str
5616         life : str
5617         relations : RemoteRelationsChange
5618         '''
5619         self.application_tag = application_tag
5620         self.life = life
5621         self.relations = RemoteRelationsChange.from_json(relations) if relations else None
5622
5623
5624
5625 class RemoteApplicationInfo(Type):
5626     _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'}
5627     _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'}
5628     def __init__(self, application_url=None, description=None, endpoints=None, icon_url_path=None, model_tag=None, name=None, source_model_label=None):
5629         '''
5630         application_url : str
5631         description : str
5632         endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
5633         icon_url_path : str
5634         model_tag : str
5635         name : str
5636         source_model_label : str
5637         '''
5638         self.application_url = application_url
5639         self.description = description
5640         self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
5641         self.icon_url_path = icon_url_path
5642         self.model_tag = model_tag
5643         self.name = name
5644         self.source_model_label = source_model_label
5645
5646
5647
5648 class RemoteApplicationInfoResult(Type):
5649     _toSchema = {'error': 'error', 'result': 'result'}
5650     _toPy = {'error': 'error', 'result': 'result'}
5651     def __init__(self, error=None, result=None):
5652         '''
5653         error : Error
5654         result : RemoteApplicationInfo
5655         '''
5656         self.error = Error.from_json(error) if error else None
5657         self.result = RemoteApplicationInfo.from_json(result) if result else None
5658
5659
5660
5661 class RemoteApplicationInfoResults(Type):
5662     _toSchema = {'results': 'results'}
5663     _toPy = {'results': 'results'}
5664     def __init__(self, results=None):
5665         '''
5666         results : typing.Sequence<+T_co>[~RemoteApplicationInfoResult]<~RemoteApplicationInfoResult>
5667         '''
5668         self.results = [RemoteApplicationInfoResult.from_json(o) for o in results or []]
5669
5670
5671
5672 class RemoteApplicationStatus(Type):
5673     _toSchema = {'application_name': 'application-name', 'application_url': 'application-url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
5674     _toPy = {'application-name': 'application_name', 'application-url': 'application_url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
5675     def __init__(self, application_name=None, application_url=None, endpoints=None, err=None, life=None, relations=None, status=None):
5676         '''
5677         application_name : str
5678         application_url : str
5679         endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
5680         err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
5681         life : str
5682         relations : typing.Sequence<+T_co>[str]
5683         status : DetailedStatus
5684         '''
5685         self.application_name = application_name
5686         self.application_url = application_url
5687         self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
5688         self.err = err
5689         self.life = life
5690         self.relations = relations
5691         self.status = DetailedStatus.from_json(status) if status else None
5692
5693
5694
5695 class RemoteApplicationWatchResult(Type):
5696     _toSchema = {'change': 'change', 'error': 'error', 'id_': 'id'}
5697     _toPy = {'change': 'change', 'error': 'error', 'id': 'id_'}
5698     def __init__(self, change=None, error=None, id_=None):
5699         '''
5700         change : RemoteApplicationChange
5701         error : Error
5702         id_ : str
5703         '''
5704         self.change = RemoteApplicationChange.from_json(change) if change else None
5705         self.error = Error.from_json(error) if error else None
5706         self.id_ = id_
5707
5708
5709
5710 class RemoteEndpoint(Type):
5711     _toSchema = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'role': 'role', 'scope': 'scope'}
5712     _toPy = {'interface': 'interface', 'limit': 'limit', 'name': 'name', 'role': 'role', 'scope': 'scope'}
5713     def __init__(self, interface=None, limit=None, name=None, role=None, scope=None):
5714         '''
5715         interface : str
5716         limit : int
5717         name : str
5718         role : str
5719         scope : str
5720         '''
5721         self.interface = interface
5722         self.limit = limit
5723         self.name = name
5724         self.role = role
5725         self.scope = scope
5726
5727
5728
5729 class RemoteEntityId(Type):
5730     _toSchema = {'model_uuid': 'model-uuid', 'token': 'token'}
5731     _toPy = {'model-uuid': 'model_uuid', 'token': 'token'}
5732     def __init__(self, model_uuid=None, token=None):
5733         '''
5734         model_uuid : str
5735         token : str
5736         '''
5737         self.model_uuid = model_uuid
5738         self.token = token
5739
5740
5741
5742 class RemoteRelationChange(Type):
5743     _toSchema = {'changed_units': 'changed-units', 'departed_units': 'departed-units', 'id_': 'id', 'life': 'life'}
5744     _toPy = {'changed-units': 'changed_units', 'departed-units': 'departed_units', 'id': 'id_', 'life': 'life'}
5745     def __init__(self, changed_units=None, departed_units=None, id_=None, life=None):
5746         '''
5747         changed_units : typing.Mapping<~KT, +VT_co>[str, ~RemoteRelationUnitChange]<~RemoteRelationUnitChange>
5748         departed_units : typing.Sequence<+T_co>[str]
5749         id_ : int
5750         life : str
5751         '''
5752         self.changed_units = changed_units
5753         self.departed_units = departed_units
5754         self.id_ = id_
5755         self.life = life
5756
5757
5758
5759 class RemoteRelationUnitChange(Type):
5760     _toSchema = {'settings': 'settings', 'unit_id': 'unit-id'}
5761     _toPy = {'settings': 'settings', 'unit-id': 'unit_id'}
5762     def __init__(self, settings=None, unit_id=None):
5763         '''
5764         settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
5765         unit_id : RemoteEntityId
5766         '''
5767         self.settings = settings
5768         self.unit_id = RemoteEntityId.from_json(unit_id) if unit_id else None
5769
5770
5771
5772 class RemoteRelationsChange(Type):
5773     _toSchema = {'changed': 'changed', 'initial': 'initial', 'removed': 'removed'}
5774     _toPy = {'changed': 'changed', 'initial': 'initial', 'removed': 'removed'}
5775     def __init__(self, changed=None, initial=None, removed=None):
5776         '''
5777         changed : typing.Sequence<+T_co>[~RemoteRelationChange]<~RemoteRelationChange>
5778         initial : bool
5779         removed : typing.Sequence<+T_co>[int]
5780         '''
5781         self.changed = [RemoteRelationChange.from_json(o) for o in changed or []]
5782         self.initial = initial
5783         self.removed = removed
5784
5785
5786
5787 class RemoteRelationsWatchResult(Type):
5788     _toSchema = {'change': 'change', 'error': 'error', 'remoterelationswatcherid': 'RemoteRelationsWatcherId'}
5789     _toPy = {'RemoteRelationsWatcherId': 'remoterelationswatcherid', 'change': 'change', 'error': 'error'}
5790     def __init__(self, remoterelationswatcherid=None, change=None, error=None):
5791         '''
5792         remoterelationswatcherid : str
5793         change : RemoteRelationsChange
5794         error : Error
5795         '''
5796         self.remoterelationswatcherid = remoterelationswatcherid
5797         self.change = RemoteRelationsChange.from_json(change) if change else None
5798         self.error = Error.from_json(error) if error else None
5799
5800
5801
5802 class RemoveBlocksArgs(Type):
5803     _toSchema = {'all_': 'all'}
5804     _toPy = {'all': 'all_'}
5805     def __init__(self, all_=None):
5806         '''
5807         all_ : bool
5808         '''
5809         self.all_ = all_
5810
5811
5812
5813 class ResolveCharmResult(Type):
5814     _toSchema = {'error': 'error', 'url': 'url'}
5815     _toPy = {'error': 'error', 'url': 'url'}
5816     def __init__(self, error=None, url=None):
5817         '''
5818         error : str
5819         url : str
5820         '''
5821         self.error = error
5822         self.url = url
5823
5824
5825
5826 class ResolveCharmResults(Type):
5827     _toSchema = {'urls': 'urls'}
5828     _toPy = {'urls': 'urls'}
5829     def __init__(self, urls=None):
5830         '''
5831         urls : typing.Sequence<+T_co>[~ResolveCharmResult]<~ResolveCharmResult>
5832         '''
5833         self.urls = [ResolveCharmResult.from_json(o) for o in urls or []]
5834
5835
5836
5837 class ResolveCharms(Type):
5838     _toSchema = {'references': 'references'}
5839     _toPy = {'references': 'references'}
5840     def __init__(self, references=None):
5841         '''
5842         references : typing.Sequence<+T_co>[str]
5843         '''
5844         self.references = references
5845
5846
5847
5848 class Resolved(Type):
5849     _toSchema = {'retry': 'retry', 'unit_name': 'unit-name'}
5850     _toPy = {'retry': 'retry', 'unit-name': 'unit_name'}
5851     def __init__(self, retry=None, unit_name=None):
5852         '''
5853         retry : bool
5854         unit_name : str
5855         '''
5856         self.retry = retry
5857         self.unit_name = unit_name
5858
5859
5860
5861 class ResolvedModeResult(Type):
5862     _toSchema = {'error': 'error', 'mode': 'mode'}
5863     _toPy = {'error': 'error', 'mode': 'mode'}
5864     def __init__(self, error=None, mode=None):
5865         '''
5866         error : Error
5867         mode : str
5868         '''
5869         self.error = Error.from_json(error) if error else None
5870         self.mode = mode
5871
5872
5873
5874 class ResolvedModeResults(Type):
5875     _toSchema = {'results': 'results'}
5876     _toPy = {'results': 'results'}
5877     def __init__(self, results=None):
5878         '''
5879         results : typing.Sequence<+T_co>[~ResolvedModeResult]<~ResolvedModeResult>
5880         '''
5881         self.results = [ResolvedModeResult.from_json(o) for o in results or []]
5882
5883
5884
5885 class Resource(Type):
5886     _toSchema = {'application': 'application', 'charmresource': 'CharmResource', 'id_': 'id', 'pending_id': 'pending-id', 'timestamp': 'timestamp', 'username': 'username'}
5887     _toPy = {'CharmResource': 'charmresource', 'application': 'application', 'id': 'id_', 'pending-id': 'pending_id', 'timestamp': 'timestamp', 'username': 'username'}
5888     def __init__(self, charmresource=None, application=None, id_=None, pending_id=None, timestamp=None, username=None):
5889         '''
5890         charmresource : CharmResource
5891         application : str
5892         id_ : str
5893         pending_id : str
5894         timestamp : str
5895         username : str
5896         '''
5897         self.charmresource = CharmResource.from_json(charmresource) if charmresource else None
5898         self.application = application
5899         self.id_ = id_
5900         self.pending_id = pending_id
5901         self.timestamp = timestamp
5902         self.username = username
5903
5904
5905
5906 class ResourceResult(Type):
5907     _toSchema = {'errorresult': 'ErrorResult', 'resource': 'resource'}
5908     _toPy = {'ErrorResult': 'errorresult', 'resource': 'resource'}
5909     def __init__(self, errorresult=None, resource=None):
5910         '''
5911         errorresult : ErrorResult
5912         resource : Resource
5913         '''
5914         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
5915         self.resource = Resource.from_json(resource) if resource else None
5916
5917
5918
5919 class ResourcesResult(Type):
5920     _toSchema = {'charm_store_resources': 'charm-store-resources', 'errorresult': 'ErrorResult', 'resources': 'resources', 'unit_resources': 'unit-resources'}
5921     _toPy = {'ErrorResult': 'errorresult', 'charm-store-resources': 'charm_store_resources', 'resources': 'resources', 'unit-resources': 'unit_resources'}
5922     def __init__(self, errorresult=None, charm_store_resources=None, resources=None, unit_resources=None):
5923         '''
5924         errorresult : ErrorResult
5925         charm_store_resources : typing.Sequence<+T_co>[~CharmResource]<~CharmResource>
5926         resources : typing.Sequence<+T_co>[~Resource]<~Resource>
5927         unit_resources : typing.Sequence<+T_co>[~UnitResources]<~UnitResources>
5928         '''
5929         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
5930         self.charm_store_resources = [CharmResource.from_json(o) for o in charm_store_resources or []]
5931         self.resources = [Resource.from_json(o) for o in resources or []]
5932         self.unit_resources = [UnitResources.from_json(o) for o in unit_resources or []]
5933
5934
5935
5936 class ResourcesResults(Type):
5937     _toSchema = {'results': 'results'}
5938     _toPy = {'results': 'results'}
5939     def __init__(self, results=None):
5940         '''
5941         results : typing.Sequence<+T_co>[~ResourcesResult]<~ResourcesResult>
5942         '''
5943         self.results = [ResourcesResult.from_json(o) for o in results or []]
5944
5945
5946
5947 class RestoreArgs(Type):
5948     _toSchema = {'backup_id': 'backup-id'}
5949     _toPy = {'backup-id': 'backup_id'}
5950     def __init__(self, backup_id=None):
5951         '''
5952         backup_id : str
5953         '''
5954         self.backup_id = backup_id
5955
5956
5957
5958 class ResumeReplicationParams(Type):
5959     _toSchema = {'members': 'members'}
5960     _toPy = {'members': 'members'}
5961     def __init__(self, members=None):
5962         '''
5963         members : typing.Sequence<+T_co>[~Member]<~Member>
5964         '''
5965         self.members = [Member.from_json(o) for o in members or []]
5966
5967
5968
5969 class RetryStrategy(Type):
5970     _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'}
5971     _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'}
5972     def __init__(self, jitter_retry_time=None, max_retry_time=None, min_retry_time=None, retry_time_factor=None, should_retry=None):
5973         '''
5974         jitter_retry_time : bool
5975         max_retry_time : int
5976         min_retry_time : int
5977         retry_time_factor : int
5978         should_retry : bool
5979         '''
5980         self.jitter_retry_time = jitter_retry_time
5981         self.max_retry_time = max_retry_time
5982         self.min_retry_time = min_retry_time
5983         self.retry_time_factor = retry_time_factor
5984         self.should_retry = should_retry
5985
5986
5987
5988 class RetryStrategyResult(Type):
5989     _toSchema = {'error': 'error', 'result': 'result'}
5990     _toPy = {'error': 'error', 'result': 'result'}
5991     def __init__(self, error=None, result=None):
5992         '''
5993         error : Error
5994         result : RetryStrategy
5995         '''
5996         self.error = Error.from_json(error) if error else None
5997         self.result = RetryStrategy.from_json(result) if result else None
5998
5999
6000
6001 class RetryStrategyResults(Type):
6002     _toSchema = {'results': 'results'}
6003     _toPy = {'results': 'results'}
6004     def __init__(self, results=None):
6005         '''
6006         results : typing.Sequence<+T_co>[~RetryStrategyResult]<~RetryStrategyResult>
6007         '''
6008         self.results = [RetryStrategyResult.from_json(o) for o in results or []]
6009
6010
6011
6012 class RunParams(Type):
6013     _toSchema = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
6014     _toPy = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
6015     def __init__(self, applications=None, commands=None, machines=None, timeout=None, units=None):
6016         '''
6017         applications : typing.Sequence<+T_co>[str]
6018         commands : str
6019         machines : typing.Sequence<+T_co>[str]
6020         timeout : int
6021         units : typing.Sequence<+T_co>[str]
6022         '''
6023         self.applications = applications
6024         self.commands = commands
6025         self.machines = machines
6026         self.timeout = timeout
6027         self.units = units
6028
6029
6030
6031 class SSHAddressResult(Type):
6032     _toSchema = {'address': 'address', 'error': 'error'}
6033     _toPy = {'address': 'address', 'error': 'error'}
6034     def __init__(self, address=None, error=None):
6035         '''
6036         address : str
6037         error : Error
6038         '''
6039         self.address = address
6040         self.error = Error.from_json(error) if error else None
6041
6042
6043
6044 class SSHAddressResults(Type):
6045     _toSchema = {'results': 'results'}
6046     _toPy = {'results': 'results'}
6047     def __init__(self, results=None):
6048         '''
6049         results : typing.Sequence<+T_co>[~SSHAddressResult]<~SSHAddressResult>
6050         '''
6051         self.results = [SSHAddressResult.from_json(o) for o in results or []]
6052
6053
6054
6055 class SSHAddressesResult(Type):
6056     _toSchema = {'addresses': 'addresses', 'error': 'error'}
6057     _toPy = {'addresses': 'addresses', 'error': 'error'}
6058     def __init__(self, addresses=None, error=None):
6059         '''
6060         addresses : typing.Sequence<+T_co>[str]
6061         error : Error
6062         '''
6063         self.addresses = addresses
6064         self.error = Error.from_json(error) if error else None
6065
6066
6067
6068 class SSHAddressesResults(Type):
6069     _toSchema = {'results': 'results'}
6070     _toPy = {'results': 'results'}
6071     def __init__(self, results=None):
6072         '''
6073         results : typing.Sequence<+T_co>[~SSHAddressesResult]<~SSHAddressesResult>
6074         '''
6075         self.results = [SSHAddressesResult.from_json(o) for o in results or []]
6076
6077
6078
6079 class SSHHostKeySet(Type):
6080     _toSchema = {'entity_keys': 'entity-keys'}
6081     _toPy = {'entity-keys': 'entity_keys'}
6082     def __init__(self, entity_keys=None):
6083         '''
6084         entity_keys : typing.Sequence<+T_co>[~SSHHostKeys]<~SSHHostKeys>
6085         '''
6086         self.entity_keys = [SSHHostKeys.from_json(o) for o in entity_keys or []]
6087
6088
6089
6090 class SSHHostKeys(Type):
6091     _toSchema = {'public_keys': 'public-keys', 'tag': 'tag'}
6092     _toPy = {'public-keys': 'public_keys', 'tag': 'tag'}
6093     def __init__(self, public_keys=None, tag=None):
6094         '''
6095         public_keys : typing.Sequence<+T_co>[str]
6096         tag : str
6097         '''
6098         self.public_keys = public_keys
6099         self.tag = tag
6100
6101
6102
6103 class SSHProxyResult(Type):
6104     _toSchema = {'use_proxy': 'use-proxy'}
6105     _toPy = {'use-proxy': 'use_proxy'}
6106     def __init__(self, use_proxy=None):
6107         '''
6108         use_proxy : bool
6109         '''
6110         self.use_proxy = use_proxy
6111
6112
6113
6114 class SSHPublicKeysResult(Type):
6115     _toSchema = {'error': 'error', 'public_keys': 'public-keys'}
6116     _toPy = {'error': 'error', 'public-keys': 'public_keys'}
6117     def __init__(self, error=None, public_keys=None):
6118         '''
6119         error : Error
6120         public_keys : typing.Sequence<+T_co>[str]
6121         '''
6122         self.error = Error.from_json(error) if error else None
6123         self.public_keys = public_keys
6124
6125
6126
6127 class SSHPublicKeysResults(Type):
6128     _toSchema = {'results': 'results'}
6129     _toPy = {'results': 'results'}
6130     def __init__(self, results=None):
6131         '''
6132         results : typing.Sequence<+T_co>[~SSHPublicKeysResult]<~SSHPublicKeysResult>
6133         '''
6134         self.results = [SSHPublicKeysResult.from_json(o) for o in results or []]
6135
6136
6137
6138 class SerializedModel(Type):
6139     _toSchema = {'bytes_': 'bytes', 'charms': 'charms', 'tools': 'tools'}
6140     _toPy = {'bytes': 'bytes_', 'charms': 'charms', 'tools': 'tools'}
6141     def __init__(self, bytes_=None, charms=None, tools=None):
6142         '''
6143         bytes_ : typing.Sequence<+T_co>[int]
6144         charms : typing.Sequence<+T_co>[str]
6145         tools : typing.Sequence<+T_co>[~SerializedModelTools]<~SerializedModelTools>
6146         '''
6147         self.bytes_ = bytes_
6148         self.charms = charms
6149         self.tools = [SerializedModelTools.from_json(o) for o in tools or []]
6150
6151
6152
6153 class SerializedModelResource(Type):
6154     _toSchema = {'application': 'application', 'application_revision': 'application-revision', 'charmstore_revision': 'charmstore-revision', 'name': 'name', 'unit_revisions': 'unit-revisions'}
6155     _toPy = {'application': 'application', 'application-revision': 'application_revision', 'charmstore-revision': 'charmstore_revision', 'name': 'name', 'unit-revisions': 'unit_revisions'}
6156     def __init__(self, application=None, application_revision=None, charmstore_revision=None, name=None, unit_revisions=None):
6157         '''
6158         application : str
6159         application_revision : SerializedModelResourceRevision
6160         charmstore_revision : SerializedModelResourceRevision
6161         name : str
6162         unit_revisions : typing.Mapping<~KT, +VT_co>[str, ~SerializedModelResourceRevision]<~SerializedModelResourceRevision>
6163         '''
6164         self.application = application
6165         self.application_revision = SerializedModelResourceRevision.from_json(application_revision) if application_revision else None
6166         self.charmstore_revision = SerializedModelResourceRevision.from_json(charmstore_revision) if charmstore_revision else None
6167         self.name = name
6168         self.unit_revisions = unit_revisions
6169
6170
6171
6172 class SerializedModelResourceRevision(Type):
6173     _toSchema = {'description': 'description', 'fingerprint': 'fingerprint', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'timestamp': 'timestamp', 'type_': 'type', 'username': 'username'}
6174     _toPy = {'description': 'description', 'fingerprint': 'fingerprint', 'origin': 'origin', 'path': 'path', 'revision': 'revision', 'size': 'size', 'timestamp': 'timestamp', 'type': 'type_', 'username': 'username'}
6175     def __init__(self, description=None, fingerprint=None, origin=None, path=None, revision=None, size=None, timestamp=None, type_=None, username=None):
6176         '''
6177         description : str
6178         fingerprint : str
6179         origin : str
6180         path : str
6181         revision : int
6182         size : int
6183         timestamp : str
6184         type_ : str
6185         username : str
6186         '''
6187         self.description = description
6188         self.fingerprint = fingerprint
6189         self.origin = origin
6190         self.path = path
6191         self.revision = revision
6192         self.size = size
6193         self.timestamp = timestamp
6194         self.type_ = type_
6195         self.username = username
6196
6197
6198
6199 class SerializedModelTools(Type):
6200     _toSchema = {'uri': 'uri', 'version': 'version'}
6201     _toPy = {'uri': 'uri', 'version': 'version'}
6202     def __init__(self, uri=None, version=None):
6203         '''
6204         uri : str
6205         version : str
6206         '''
6207         self.uri = uri
6208         self.version = version
6209
6210
6211
6212 class SetConstraints(Type):
6213     _toSchema = {'application': 'application', 'constraints': 'constraints'}
6214     _toPy = {'application': 'application', 'constraints': 'constraints'}
6215     def __init__(self, application=None, constraints=None):
6216         '''
6217         application : str
6218         constraints : Value
6219         '''
6220         self.application = application
6221         self.constraints = Value.from_json(constraints) if constraints else None
6222
6223
6224
6225 class SetMachineBlockDevices(Type):
6226     _toSchema = {'machine_block_devices': 'machine-block-devices'}
6227     _toPy = {'machine-block-devices': 'machine_block_devices'}
6228     def __init__(self, machine_block_devices=None):
6229         '''
6230         machine_block_devices : typing.Sequence<+T_co>[~MachineBlockDevices]<~MachineBlockDevices>
6231         '''
6232         self.machine_block_devices = [MachineBlockDevices.from_json(o) for o in machine_block_devices or []]
6233
6234
6235
6236 class SetMachineNetworkConfig(Type):
6237     _toSchema = {'config': 'config', 'tag': 'tag'}
6238     _toPy = {'config': 'config', 'tag': 'tag'}
6239     def __init__(self, config=None, tag=None):
6240         '''
6241         config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
6242         tag : str
6243         '''
6244         self.config = [NetworkConfig.from_json(o) for o in config or []]
6245         self.tag = tag
6246
6247
6248
6249 class SetMachinesAddresses(Type):
6250     _toSchema = {'machine_addresses': 'machine-addresses'}
6251     _toPy = {'machine-addresses': 'machine_addresses'}
6252     def __init__(self, machine_addresses=None):
6253         '''
6254         machine_addresses : typing.Sequence<+T_co>[~MachineAddresses]<~MachineAddresses>
6255         '''
6256         self.machine_addresses = [MachineAddresses.from_json(o) for o in machine_addresses or []]
6257
6258
6259
6260 class SetMigrationPhaseArgs(Type):
6261     _toSchema = {'phase': 'phase'}
6262     _toPy = {'phase': 'phase'}
6263     def __init__(self, phase=None):
6264         '''
6265         phase : str
6266         '''
6267         self.phase = phase
6268
6269
6270
6271 class SetMigrationStatusMessageArgs(Type):
6272     _toSchema = {'message': 'message'}
6273     _toPy = {'message': 'message'}
6274     def __init__(self, message=None):
6275         '''
6276         message : str
6277         '''
6278         self.message = message
6279
6280
6281
6282 class SetModelAgentVersion(Type):
6283     _toSchema = {'version': 'version'}
6284     _toPy = {'version': 'version'}
6285     def __init__(self, version=None):
6286         '''
6287         version : Number
6288         '''
6289         self.version = Number.from_json(version) if version else None
6290
6291
6292
6293 class SetModelDefaults(Type):
6294     _toSchema = {'config': 'config'}
6295     _toPy = {'config': 'config'}
6296     def __init__(self, config=None):
6297         '''
6298         config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
6299         '''
6300         self.config = [ModelDefaultValues.from_json(o) for o in config or []]
6301
6302
6303
6304 class SetPayloadStatusArg(Type):
6305     _toSchema = {'entity': 'Entity', 'status': 'status'}
6306     _toPy = {'Entity': 'entity', 'status': 'status'}
6307     def __init__(self, entity=None, status=None):
6308         '''
6309         entity : Entity
6310         status : str
6311         '''
6312         self.entity = Entity.from_json(entity) if entity else None
6313         self.status = status
6314
6315
6316
6317 class SetPayloadStatusArgs(Type):
6318     _toSchema = {'args': 'args'}
6319     _toPy = {'args': 'args'}
6320     def __init__(self, args=None):
6321         '''
6322         args : typing.Sequence<+T_co>[~SetPayloadStatusArg]<~SetPayloadStatusArg>
6323         '''
6324         self.args = [SetPayloadStatusArg.from_json(o) for o in args or []]
6325
6326
6327
6328 class SetStatus(Type):
6329     _toSchema = {'entities': 'entities'}
6330     _toPy = {'entities': 'entities'}
6331     def __init__(self, entities=None):
6332         '''
6333         entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
6334         '''
6335         self.entities = [EntityStatusArgs.from_json(o) for o in entities or []]
6336
6337
6338
6339 class SetStatusArg(Type):
6340     _toSchema = {'entity': 'Entity', 'status': 'status'}
6341     _toPy = {'Entity': 'entity', 'status': 'status'}
6342     def __init__(self, entity=None, status=None):
6343         '''
6344         entity : Entity
6345         status : str
6346         '''
6347         self.entity = Entity.from_json(entity) if entity else None
6348         self.status = status
6349
6350
6351
6352 class SetStatusArgs(Type):
6353     _toSchema = {'args': 'args'}
6354     _toPy = {'args': 'args'}
6355     def __init__(self, args=None):
6356         '''
6357         args : typing.Sequence<+T_co>[~SetStatusArg]<~SetStatusArg>
6358         '''
6359         self.args = [SetStatusArg.from_json(o) for o in args or []]
6360
6361
6362
6363 class Settings(Type):
6364     _toSchema = {'ftp': 'Ftp', 'http': 'Http', 'https': 'Https', 'noproxy': 'NoProxy'}
6365     _toPy = {'Ftp': 'ftp', 'Http': 'http', 'Https': 'https', 'NoProxy': 'noproxy'}
6366     def __init__(self, ftp=None, http=None, https=None, noproxy=None):
6367         '''
6368         ftp : str
6369         http : str
6370         https : str
6371         noproxy : str
6372         '''
6373         self.ftp = ftp
6374         self.http = http
6375         self.https = https
6376         self.noproxy = noproxy
6377
6378
6379
6380 class SettingsResult(Type):
6381     _toSchema = {'error': 'error', 'settings': 'settings'}
6382     _toPy = {'error': 'error', 'settings': 'settings'}
6383     def __init__(self, error=None, settings=None):
6384         '''
6385         error : Error
6386         settings : typing.Mapping<~KT, +VT_co>[str, str]
6387         '''
6388         self.error = Error.from_json(error) if error else None
6389         self.settings = settings
6390
6391
6392
6393 class SettingsResults(Type):
6394     _toSchema = {'results': 'results'}
6395     _toPy = {'results': 'results'}
6396     def __init__(self, results=None):
6397         '''
6398         results : typing.Sequence<+T_co>[~SettingsResult]<~SettingsResult>
6399         '''
6400         self.results = [SettingsResult.from_json(o) for o in results or []]
6401
6402
6403
6404 class SingularClaim(Type):
6405     _toSchema = {'controller_tag': 'controller-tag', 'duration': 'duration', 'model_tag': 'model-tag'}
6406     _toPy = {'controller-tag': 'controller_tag', 'duration': 'duration', 'model-tag': 'model_tag'}
6407     def __init__(self, controller_tag=None, duration=None, model_tag=None):
6408         '''
6409         controller_tag : str
6410         duration : int
6411         model_tag : str
6412         '''
6413         self.controller_tag = controller_tag
6414         self.duration = duration
6415         self.model_tag = model_tag
6416
6417
6418
6419 class SingularClaims(Type):
6420     _toSchema = {'claims': 'claims'}
6421     _toPy = {'claims': 'claims'}
6422     def __init__(self, claims=None):
6423         '''
6424         claims : typing.Sequence<+T_co>[~SingularClaim]<~SingularClaim>
6425         '''
6426         self.claims = [SingularClaim.from_json(o) for o in claims or []]
6427
6428
6429
6430 class Space(Type):
6431     _toSchema = {'error': 'error', 'name': 'name', 'subnets': 'subnets'}
6432     _toPy = {'error': 'error', 'name': 'name', 'subnets': 'subnets'}
6433     def __init__(self, error=None, name=None, subnets=None):
6434         '''
6435         error : Error
6436         name : str
6437         subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
6438         '''
6439         self.error = Error.from_json(error) if error else None
6440         self.name = name
6441         self.subnets = [Subnet.from_json(o) for o in subnets or []]
6442
6443
6444
6445 class SpaceResult(Type):
6446     _toSchema = {'error': 'error', 'tag': 'tag'}
6447     _toPy = {'error': 'error', 'tag': 'tag'}
6448     def __init__(self, error=None, tag=None):
6449         '''
6450         error : Error
6451         tag : str
6452         '''
6453         self.error = Error.from_json(error) if error else None
6454         self.tag = tag
6455
6456
6457
6458 class SpaceResults(Type):
6459     _toSchema = {'results': 'results'}
6460     _toPy = {'results': 'results'}
6461     def __init__(self, results=None):
6462         '''
6463         results : typing.Sequence<+T_co>[~SpaceResult]<~SpaceResult>
6464         '''
6465         self.results = [SpaceResult.from_json(o) for o in results or []]
6466
6467
6468
6469 class StateServingInfo(Type):
6470     _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'}
6471     _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'}
6472     def __init__(self, api_port=None, ca_private_key=None, cert=None, private_key=None, shared_secret=None, state_port=None, system_identity=None):
6473         '''
6474         api_port : int
6475         ca_private_key : str
6476         cert : str
6477         private_key : str
6478         shared_secret : str
6479         state_port : int
6480         system_identity : str
6481         '''
6482         self.api_port = api_port
6483         self.ca_private_key = ca_private_key
6484         self.cert = cert
6485         self.private_key = private_key
6486         self.shared_secret = shared_secret
6487         self.state_port = state_port
6488         self.system_identity = system_identity
6489
6490
6491
6492 class StatusHistoryFilter(Type):
6493     _toSchema = {'date': 'date', 'delta': 'delta', 'size': 'size'}
6494     _toPy = {'date': 'date', 'delta': 'delta', 'size': 'size'}
6495     def __init__(self, date=None, delta=None, size=None):
6496         '''
6497         date : str
6498         delta : int
6499         size : int
6500         '''
6501         self.date = date
6502         self.delta = delta
6503         self.size = size
6504
6505
6506
6507 class StatusHistoryPruneArgs(Type):
6508     _toSchema = {'max_history_mb': 'max-history-mb', 'max_history_time': 'max-history-time'}
6509     _toPy = {'max-history-mb': 'max_history_mb', 'max-history-time': 'max_history_time'}
6510     def __init__(self, max_history_mb=None, max_history_time=None):
6511         '''
6512         max_history_mb : int
6513         max_history_time : int
6514         '''
6515         self.max_history_mb = max_history_mb
6516         self.max_history_time = max_history_time
6517
6518
6519
6520 class StatusHistoryRequest(Type):
6521     _toSchema = {'filter_': 'filter', 'historykind': 'historyKind', 'size': 'size', 'tag': 'tag'}
6522     _toPy = {'filter': 'filter_', 'historyKind': 'historykind', 'size': 'size', 'tag': 'tag'}
6523     def __init__(self, filter_=None, historykind=None, size=None, tag=None):
6524         '''
6525         filter_ : StatusHistoryFilter
6526         historykind : str
6527         size : int
6528         tag : str
6529         '''
6530         self.filter_ = StatusHistoryFilter.from_json(filter_) if filter_ else None
6531         self.historykind = historykind
6532         self.size = size
6533         self.tag = tag
6534
6535
6536
6537 class StatusHistoryRequests(Type):
6538     _toSchema = {'requests': 'requests'}
6539     _toPy = {'requests': 'requests'}
6540     def __init__(self, requests=None):
6541         '''
6542         requests : typing.Sequence<+T_co>[~StatusHistoryRequest]<~StatusHistoryRequest>
6543         '''
6544         self.requests = [StatusHistoryRequest.from_json(o) for o in requests or []]
6545
6546
6547
6548 class StatusHistoryResult(Type):
6549     _toSchema = {'error': 'error', 'history': 'history'}
6550     _toPy = {'error': 'error', 'history': 'history'}
6551     def __init__(self, error=None, history=None):
6552         '''
6553         error : Error
6554         history : History
6555         '''
6556         self.error = Error.from_json(error) if error else None
6557         self.history = History.from_json(history) if history else None
6558
6559
6560
6561 class StatusHistoryResults(Type):
6562     _toSchema = {'results': 'results'}
6563     _toPy = {'results': 'results'}
6564     def __init__(self, results=None):
6565         '''
6566         results : typing.Sequence<+T_co>[~StatusHistoryResult]<~StatusHistoryResult>
6567         '''
6568         self.results = [StatusHistoryResult.from_json(o) for o in results or []]
6569
6570
6571
6572 class StatusParams(Type):
6573     _toSchema = {'patterns': 'patterns'}
6574     _toPy = {'patterns': 'patterns'}
6575     def __init__(self, patterns=None):
6576         '''
6577         patterns : typing.Sequence<+T_co>[str]
6578         '''
6579         self.patterns = patterns
6580
6581
6582
6583 class StatusResult(Type):
6584     _toSchema = {'data': 'data', 'error': 'error', 'id_': 'id', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
6585     _toPy = {'data': 'data', 'error': 'error', 'id': 'id_', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
6586     def __init__(self, data=None, error=None, id_=None, info=None, life=None, since=None, status=None):
6587         '''
6588         data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
6589         error : Error
6590         id_ : str
6591         info : str
6592         life : str
6593         since : str
6594         status : str
6595         '''
6596         self.data = data
6597         self.error = Error.from_json(error) if error else None
6598         self.id_ = id_
6599         self.info = info
6600         self.life = life
6601         self.since = since
6602         self.status = status
6603
6604
6605
6606 class StatusResults(Type):
6607     _toSchema = {'results': 'results'}
6608     _toPy = {'results': 'results'}
6609     def __init__(self, results=None):
6610         '''
6611         results : typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
6612         '''
6613         self.results = [StatusResult.from_json(o) for o in results or []]
6614
6615
6616
6617 class StorageAddParams(Type):
6618     _toSchema = {'name': 'name', 'storage': 'storage', 'unit': 'unit'}
6619     _toPy = {'name': 'name', 'storage': 'storage', 'unit': 'unit'}
6620     def __init__(self, name=None, storage=None, unit=None):
6621         '''
6622         name : str
6623         storage : StorageConstraints
6624         unit : str
6625         '''
6626         self.name = name
6627         self.storage = StorageConstraints.from_json(storage) if storage else None
6628         self.unit = unit
6629
6630
6631
6632 class StorageAttachment(Type):
6633     _toSchema = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner_tag': 'owner-tag', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
6634     _toPy = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner-tag': 'owner_tag', 'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
6635     def __init__(self, kind=None, life=None, location=None, owner_tag=None, storage_tag=None, unit_tag=None):
6636         '''
6637         kind : int
6638         life : str
6639         location : str
6640         owner_tag : str
6641         storage_tag : str
6642         unit_tag : str
6643         '''
6644         self.kind = kind
6645         self.life = life
6646         self.location = location
6647         self.owner_tag = owner_tag
6648         self.storage_tag = storage_tag
6649         self.unit_tag = unit_tag
6650
6651
6652
6653 class StorageAttachmentDetails(Type):
6654     _toSchema = {'location': 'location', 'machine_tag': 'machine-tag', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
6655     _toPy = {'location': 'location', 'machine-tag': 'machine_tag', 'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
6656     def __init__(self, location=None, machine_tag=None, storage_tag=None, unit_tag=None):
6657         '''
6658         location : str
6659         machine_tag : str
6660         storage_tag : str
6661         unit_tag : str
6662         '''
6663         self.location = location
6664         self.machine_tag = machine_tag
6665         self.storage_tag = storage_tag
6666         self.unit_tag = unit_tag
6667
6668
6669
6670 class StorageAttachmentId(Type):
6671     _toSchema = {'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
6672     _toPy = {'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
6673     def __init__(self, storage_tag=None, unit_tag=None):
6674         '''
6675         storage_tag : str
6676         unit_tag : str
6677         '''
6678         self.storage_tag = storage_tag
6679         self.unit_tag = unit_tag
6680
6681
6682
6683 class StorageAttachmentIds(Type):
6684     _toSchema = {'ids': 'ids'}
6685     _toPy = {'ids': 'ids'}
6686     def __init__(self, ids=None):
6687         '''
6688         ids : typing.Sequence<+T_co>[~StorageAttachmentId]<~StorageAttachmentId>
6689         '''
6690         self.ids = [StorageAttachmentId.from_json(o) for o in ids or []]
6691
6692
6693
6694 class StorageAttachmentIdsResult(Type):
6695     _toSchema = {'error': 'error', 'result': 'result'}
6696     _toPy = {'error': 'error', 'result': 'result'}
6697     def __init__(self, error=None, result=None):
6698         '''
6699         error : Error
6700         result : StorageAttachmentIds
6701         '''
6702         self.error = Error.from_json(error) if error else None
6703         self.result = StorageAttachmentIds.from_json(result) if result else None
6704
6705
6706
6707 class StorageAttachmentIdsResults(Type):
6708     _toSchema = {'results': 'results'}
6709     _toPy = {'results': 'results'}
6710     def __init__(self, results=None):
6711         '''
6712         results : typing.Sequence<+T_co>[~StorageAttachmentIdsResult]<~StorageAttachmentIdsResult>
6713         '''
6714         self.results = [StorageAttachmentIdsResult.from_json(o) for o in results or []]
6715
6716
6717
6718 class StorageAttachmentResult(Type):
6719     _toSchema = {'error': 'error', 'result': 'result'}
6720     _toPy = {'error': 'error', 'result': 'result'}
6721     def __init__(self, error=None, result=None):
6722         '''
6723         error : Error
6724         result : StorageAttachment
6725         '''
6726         self.error = Error.from_json(error) if error else None
6727         self.result = StorageAttachment.from_json(result) if result else None
6728
6729
6730
6731 class StorageAttachmentResults(Type):
6732     _toSchema = {'results': 'results'}
6733     _toPy = {'results': 'results'}
6734     def __init__(self, results=None):
6735         '''
6736         results : typing.Sequence<+T_co>[~StorageAttachmentResult]<~StorageAttachmentResult>
6737         '''
6738         self.results = [StorageAttachmentResult.from_json(o) for o in results or []]
6739
6740
6741
6742 class StorageConstraints(Type):
6743     _toSchema = {'count': 'count', 'pool': 'pool', 'size': 'size'}
6744     _toPy = {'count': 'count', 'pool': 'pool', 'size': 'size'}
6745     def __init__(self, count=None, pool=None, size=None):
6746         '''
6747         count : int
6748         pool : str
6749         size : int
6750         '''
6751         self.count = count
6752         self.pool = pool
6753         self.size = size
6754
6755
6756
6757 class StorageDetails(Type):
6758     _toSchema = {'attachments': 'attachments', 'kind': 'kind', 'owner_tag': 'owner-tag', 'persistent': 'persistent', 'status': 'status', 'storage_tag': 'storage-tag'}
6759     _toPy = {'attachments': 'attachments', 'kind': 'kind', 'owner-tag': 'owner_tag', 'persistent': 'persistent', 'status': 'status', 'storage-tag': 'storage_tag'}
6760     def __init__(self, attachments=None, kind=None, owner_tag=None, persistent=None, status=None, storage_tag=None):
6761         '''
6762         attachments : typing.Mapping<~KT, +VT_co>[str, ~StorageAttachmentDetails]<~StorageAttachmentDetails>
6763         kind : int
6764         owner_tag : str
6765         persistent : bool
6766         status : EntityStatus
6767         storage_tag : str
6768         '''
6769         self.attachments = attachments
6770         self.kind = kind
6771         self.owner_tag = owner_tag
6772         self.persistent = persistent
6773         self.status = EntityStatus.from_json(status) if status else None
6774         self.storage_tag = storage_tag
6775
6776
6777
6778 class StorageDetailsListResult(Type):
6779     _toSchema = {'error': 'error', 'result': 'result'}
6780     _toPy = {'error': 'error', 'result': 'result'}
6781     def __init__(self, error=None, result=None):
6782         '''
6783         error : Error
6784         result : typing.Sequence<+T_co>[~StorageDetails]<~StorageDetails>
6785         '''
6786         self.error = Error.from_json(error) if error else None
6787         self.result = [StorageDetails.from_json(o) for o in result or []]
6788
6789
6790
6791 class StorageDetailsListResults(Type):
6792     _toSchema = {'results': 'results'}
6793     _toPy = {'results': 'results'}
6794     def __init__(self, results=None):
6795         '''
6796         results : typing.Sequence<+T_co>[~StorageDetailsListResult]<~StorageDetailsListResult>
6797         '''
6798         self.results = [StorageDetailsListResult.from_json(o) for o in results or []]
6799
6800
6801
6802 class StorageDetailsResult(Type):
6803     _toSchema = {'error': 'error', 'result': 'result'}
6804     _toPy = {'error': 'error', 'result': 'result'}
6805     def __init__(self, error=None, result=None):
6806         '''
6807         error : Error
6808         result : StorageDetails
6809         '''
6810         self.error = Error.from_json(error) if error else None
6811         self.result = StorageDetails.from_json(result) if result else None
6812
6813
6814
6815 class StorageDetailsResults(Type):
6816     _toSchema = {'results': 'results'}
6817     _toPy = {'results': 'results'}
6818     def __init__(self, results=None):
6819         '''
6820         results : typing.Sequence<+T_co>[~StorageDetailsResult]<~StorageDetailsResult>
6821         '''
6822         self.results = [StorageDetailsResult.from_json(o) for o in results or []]
6823
6824
6825
6826 class StorageFilter(Type):
6827     _toSchema = {}
6828     _toPy = {}
6829     def __init__(self):
6830         '''
6831
6832         '''
6833         pass
6834
6835
6836
6837 class StorageFilters(Type):
6838     _toSchema = {'filters': 'filters'}
6839     _toPy = {'filters': 'filters'}
6840     def __init__(self, filters=None):
6841         '''
6842         filters : typing.Sequence<+T_co>[~StorageFilter]<~StorageFilter>
6843         '''
6844         self.filters = [StorageFilter.from_json(o) for o in filters or []]
6845
6846
6847
6848 class StoragePool(Type):
6849     _toSchema = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
6850     _toPy = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
6851     def __init__(self, attrs=None, name=None, provider=None):
6852         '''
6853         attrs : typing.Mapping<~KT, +VT_co>[str, typing.Any]
6854         name : str
6855         provider : str
6856         '''
6857         self.attrs = attrs
6858         self.name = name
6859         self.provider = provider
6860
6861
6862
6863 class StoragePoolFilter(Type):
6864     _toSchema = {'names': 'names', 'providers': 'providers'}
6865     _toPy = {'names': 'names', 'providers': 'providers'}
6866     def __init__(self, names=None, providers=None):
6867         '''
6868         names : typing.Sequence<+T_co>[str]
6869         providers : typing.Sequence<+T_co>[str]
6870         '''
6871         self.names = names
6872         self.providers = providers
6873
6874
6875
6876 class StoragePoolFilters(Type):
6877     _toSchema = {'filters': 'filters'}
6878     _toPy = {'filters': 'filters'}
6879     def __init__(self, filters=None):
6880         '''
6881         filters : typing.Sequence<+T_co>[~StoragePoolFilter]<~StoragePoolFilter>
6882         '''
6883         self.filters = [StoragePoolFilter.from_json(o) for o in filters or []]
6884
6885
6886
6887 class StoragePoolsResult(Type):
6888     _toSchema = {'error': 'error', 'storage_pools': 'storage-pools'}
6889     _toPy = {'error': 'error', 'storage-pools': 'storage_pools'}
6890     def __init__(self, error=None, storage_pools=None):
6891         '''
6892         error : Error
6893         storage_pools : typing.Sequence<+T_co>[~StoragePool]<~StoragePool>
6894         '''
6895         self.error = Error.from_json(error) if error else None
6896         self.storage_pools = [StoragePool.from_json(o) for o in storage_pools or []]
6897
6898
6899
6900 class StoragePoolsResults(Type):
6901     _toSchema = {'results': 'results'}
6902     _toPy = {'results': 'results'}
6903     def __init__(self, results=None):
6904         '''
6905         results : typing.Sequence<+T_co>[~StoragePoolsResult]<~StoragePoolsResult>
6906         '''
6907         self.results = [StoragePoolsResult.from_json(o) for o in results or []]
6908
6909
6910
6911 class StoragesAddParams(Type):
6912     _toSchema = {'storages': 'storages'}
6913     _toPy = {'storages': 'storages'}
6914     def __init__(self, storages=None):
6915         '''
6916         storages : typing.Sequence<+T_co>[~StorageAddParams]<~StorageAddParams>
6917         '''
6918         self.storages = [StorageAddParams.from_json(o) for o in storages or []]
6919
6920
6921
6922 class StringBoolResult(Type):
6923     _toSchema = {'error': 'error', 'ok': 'ok', 'result': 'result'}
6924     _toPy = {'error': 'error', 'ok': 'ok', 'result': 'result'}
6925     def __init__(self, error=None, ok=None, result=None):
6926         '''
6927         error : Error
6928         ok : bool
6929         result : str
6930         '''
6931         self.error = Error.from_json(error) if error else None
6932         self.ok = ok
6933         self.result = result
6934
6935
6936
6937 class StringBoolResults(Type):
6938     _toSchema = {'results': 'results'}
6939     _toPy = {'results': 'results'}
6940     def __init__(self, results=None):
6941         '''
6942         results : typing.Sequence<+T_co>[~StringBoolResult]<~StringBoolResult>
6943         '''
6944         self.results = [StringBoolResult.from_json(o) for o in results or []]
6945
6946
6947
6948 class StringResult(Type):
6949     _toSchema = {'error': 'error', 'result': 'result'}
6950     _toPy = {'error': 'error', 'result': 'result'}
6951     def __init__(self, error=None, result=None):
6952         '''
6953         error : Error
6954         result : str
6955         '''
6956         self.error = Error.from_json(error) if error else None
6957         self.result = result
6958
6959
6960
6961 class StringResults(Type):
6962     _toSchema = {'results': 'results'}
6963     _toPy = {'results': 'results'}
6964     def __init__(self, results=None):
6965         '''
6966         results : typing.Sequence<+T_co>[~StringResult]<~StringResult>
6967         '''
6968         self.results = [StringResult.from_json(o) for o in results or []]
6969
6970
6971
6972 class StringsResult(Type):
6973     _toSchema = {'error': 'error', 'result': 'result'}
6974     _toPy = {'error': 'error', 'result': 'result'}
6975     def __init__(self, error=None, result=None):
6976         '''
6977         error : Error
6978         result : typing.Sequence<+T_co>[str]
6979         '''
6980         self.error = Error.from_json(error) if error else None
6981         self.result = result
6982
6983
6984
6985 class StringsResults(Type):
6986     _toSchema = {'results': 'results'}
6987     _toPy = {'results': 'results'}
6988     def __init__(self, results=None):
6989         '''
6990         results : typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
6991         '''
6992         self.results = [StringsResult.from_json(o) for o in results or []]
6993
6994
6995
6996 class StringsWatchResult(Type):
6997     _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
6998     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
6999     def __init__(self, changes=None, error=None, watcher_id=None):
7000         '''
7001         changes : typing.Sequence<+T_co>[str]
7002         error : Error
7003         watcher_id : str
7004         '''
7005         self.changes = changes
7006         self.error = Error.from_json(error) if error else None
7007         self.watcher_id = watcher_id
7008
7009
7010
7011 class StringsWatchResults(Type):
7012     _toSchema = {'results': 'results'}
7013     _toPy = {'results': 'results'}
7014     def __init__(self, results=None):
7015         '''
7016         results : typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
7017         '''
7018         self.results = [StringsWatchResult.from_json(o) for o in results or []]
7019
7020
7021
7022 class Subnet(Type):
7023     _toSchema = {'cidr': 'cidr', 'life': 'life', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'status': 'status', 'vlan_tag': 'vlan-tag', 'zones': 'zones'}
7024     _toPy = {'cidr': 'cidr', 'life': 'life', 'provider-id': 'provider_id', 'space-tag': 'space_tag', 'status': 'status', 'vlan-tag': 'vlan_tag', 'zones': 'zones'}
7025     def __init__(self, cidr=None, life=None, provider_id=None, space_tag=None, status=None, vlan_tag=None, zones=None):
7026         '''
7027         cidr : str
7028         life : str
7029         provider_id : str
7030         space_tag : str
7031         status : str
7032         vlan_tag : int
7033         zones : typing.Sequence<+T_co>[str]
7034         '''
7035         self.cidr = cidr
7036         self.life = life
7037         self.provider_id = provider_id
7038         self.space_tag = space_tag
7039         self.status = status
7040         self.vlan_tag = vlan_tag
7041         self.zones = zones
7042
7043
7044
7045 class SubnetsFilters(Type):
7046     _toSchema = {'space_tag': 'space-tag', 'zone': 'zone'}
7047     _toPy = {'space-tag': 'space_tag', 'zone': 'zone'}
7048     def __init__(self, space_tag=None, zone=None):
7049         '''
7050         space_tag : str
7051         zone : str
7052         '''
7053         self.space_tag = space_tag
7054         self.zone = zone
7055
7056
7057
7058 class Tools(Type):
7059     _toSchema = {'sha256': 'sha256', 'size': 'size', 'url': 'url', 'version': 'version'}
7060     _toPy = {'sha256': 'sha256', 'size': 'size', 'url': 'url', 'version': 'version'}
7061     def __init__(self, sha256=None, size=None, url=None, version=None):
7062         '''
7063         sha256 : str
7064         size : int
7065         url : str
7066         version : Binary
7067         '''
7068         self.sha256 = sha256
7069         self.size = size
7070         self.url = url
7071         self.version = Binary.from_json(version) if version else None
7072
7073
7074
7075 class ToolsResult(Type):
7076     _toSchema = {'disable_ssl_hostname_verification': 'disable-ssl-hostname-verification', 'error': 'error', 'tools': 'tools'}
7077     _toPy = {'disable-ssl-hostname-verification': 'disable_ssl_hostname_verification', 'error': 'error', 'tools': 'tools'}
7078     def __init__(self, disable_ssl_hostname_verification=None, error=None, tools=None):
7079         '''
7080         disable_ssl_hostname_verification : bool
7081         error : Error
7082         tools : typing.Sequence<+T_co>[~Tools]<~Tools>
7083         '''
7084         self.disable_ssl_hostname_verification = disable_ssl_hostname_verification
7085         self.error = Error.from_json(error) if error else None
7086         self.tools = [Tools.from_json(o) for o in tools or []]
7087
7088
7089
7090 class ToolsResults(Type):
7091     _toSchema = {'results': 'results'}
7092     _toPy = {'results': 'results'}
7093     def __init__(self, results=None):
7094         '''
7095         results : typing.Sequence<+T_co>[~ToolsResult]<~ToolsResult>
7096         '''
7097         self.results = [ToolsResult.from_json(o) for o in results or []]
7098
7099
7100
7101 class TrackArgs(Type):
7102     _toSchema = {'payloads': 'payloads'}
7103     _toPy = {'payloads': 'payloads'}
7104     def __init__(self, payloads=None):
7105         '''
7106         payloads : typing.Sequence<+T_co>[~Payload]<~Payload>
7107         '''
7108         self.payloads = [Payload.from_json(o) for o in payloads or []]
7109
7110
7111
7112 class TrackPayloadArgs(Type):
7113     _toSchema = {'payloads': 'payloads'}
7114     _toPy = {'payloads': 'payloads'}
7115     def __init__(self, payloads=None):
7116         '''
7117         payloads : typing.Sequence<+T_co>[~Payload]<~Payload>
7118         '''
7119         self.payloads = [Payload.from_json(o) for o in payloads or []]
7120
7121
7122
7123 class UndertakerModelInfo(Type):
7124     _toSchema = {'global_name': 'global-name', 'is_system': 'is-system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
7125     _toPy = {'global-name': 'global_name', 'is-system': 'is_system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
7126     def __init__(self, global_name=None, is_system=None, life=None, name=None, uuid=None):
7127         '''
7128         global_name : str
7129         is_system : bool
7130         life : str
7131         name : str
7132         uuid : str
7133         '''
7134         self.global_name = global_name
7135         self.is_system = is_system
7136         self.life = life
7137         self.name = name
7138         self.uuid = uuid
7139
7140
7141
7142 class UndertakerModelInfoResult(Type):
7143     _toSchema = {'error': 'error', 'result': 'result'}
7144     _toPy = {'error': 'error', 'result': 'result'}
7145     def __init__(self, error=None, result=None):
7146         '''
7147         error : Error
7148         result : UndertakerModelInfo
7149         '''
7150         self.error = Error.from_json(error) if error else None
7151         self.result = UndertakerModelInfo.from_json(result) if result else None
7152
7153
7154
7155 class UnitNetworkConfig(Type):
7156     _toSchema = {'binding_name': 'binding-name', 'unit_tag': 'unit-tag'}
7157     _toPy = {'binding-name': 'binding_name', 'unit-tag': 'unit_tag'}
7158     def __init__(self, binding_name=None, unit_tag=None):
7159         '''
7160         binding_name : str
7161         unit_tag : str
7162         '''
7163         self.binding_name = binding_name
7164         self.unit_tag = unit_tag
7165
7166
7167
7168 class UnitNetworkConfigResult(Type):
7169     _toSchema = {'error': 'error', 'info': 'info'}
7170     _toPy = {'error': 'error', 'info': 'info'}
7171     def __init__(self, error=None, info=None):
7172         '''
7173         error : Error
7174         info : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
7175         '''
7176         self.error = Error.from_json(error) if error else None
7177         self.info = [NetworkConfig.from_json(o) for o in info or []]
7178
7179
7180
7181 class UnitNetworkConfigResults(Type):
7182     _toSchema = {'results': 'results'}
7183     _toPy = {'results': 'results'}
7184     def __init__(self, results=None):
7185         '''
7186         results : typing.Sequence<+T_co>[~UnitNetworkConfigResult]<~UnitNetworkConfigResult>
7187         '''
7188         self.results = [UnitNetworkConfigResult.from_json(o) for o in results or []]
7189
7190
7191
7192 class UnitResourceResult(Type):
7193     _toSchema = {'errorresult': 'ErrorResult', 'resource': 'resource'}
7194     _toPy = {'ErrorResult': 'errorresult', 'resource': 'resource'}
7195     def __init__(self, errorresult=None, resource=None):
7196         '''
7197         errorresult : ErrorResult
7198         resource : Resource
7199         '''
7200         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
7201         self.resource = Resource.from_json(resource) if resource else None
7202
7203
7204
7205 class UnitResources(Type):
7206     _toSchema = {'download_progress': 'download-progress', 'entity': 'Entity', 'resources': 'resources'}
7207     _toPy = {'Entity': 'entity', 'download-progress': 'download_progress', 'resources': 'resources'}
7208     def __init__(self, entity=None, download_progress=None, resources=None):
7209         '''
7210         entity : Entity
7211         download_progress : typing.Mapping<~KT, +VT_co>[str, int]
7212         resources : typing.Sequence<+T_co>[~Resource]<~Resource>
7213         '''
7214         self.entity = Entity.from_json(entity) if entity else None
7215         self.download_progress = download_progress
7216         self.resources = [Resource.from_json(o) for o in resources or []]
7217
7218
7219
7220 class UnitResourcesResult(Type):
7221     _toSchema = {'errorresult': 'ErrorResult', 'resources': 'resources'}
7222     _toPy = {'ErrorResult': 'errorresult', 'resources': 'resources'}
7223     def __init__(self, errorresult=None, resources=None):
7224         '''
7225         errorresult : ErrorResult
7226         resources : typing.Sequence<+T_co>[~UnitResourceResult]<~UnitResourceResult>
7227         '''
7228         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
7229         self.resources = [UnitResourceResult.from_json(o) for o in resources or []]
7230
7231
7232
7233 class UnitSettings(Type):
7234     _toSchema = {'version': 'version'}
7235     _toPy = {'version': 'version'}
7236     def __init__(self, version=None):
7237         '''
7238         version : int
7239         '''
7240         self.version = version
7241
7242
7243
7244 class UnitStatus(Type):
7245     _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'}
7246     _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'}
7247     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):
7248         '''
7249         agent_status : DetailedStatus
7250         charm : str
7251         leader : bool
7252         machine : str
7253         opened_ports : typing.Sequence<+T_co>[str]
7254         public_address : str
7255         subordinates : typing.Mapping<~KT, +VT_co>[str, ~UnitStatus]<~UnitStatus>
7256         workload_status : DetailedStatus
7257         workload_version : str
7258         '''
7259         self.agent_status = DetailedStatus.from_json(agent_status) if agent_status else None
7260         self.charm = charm
7261         self.leader = leader
7262         self.machine = machine
7263         self.opened_ports = opened_ports
7264         self.public_address = public_address
7265         self.subordinates = subordinates
7266         self.workload_status = DetailedStatus.from_json(workload_status) if workload_status else None
7267         self.workload_version = workload_version
7268
7269
7270
7271 class UnitsNetworkConfig(Type):
7272     _toSchema = {'args': 'args'}
7273     _toPy = {'args': 'args'}
7274     def __init__(self, args=None):
7275         '''
7276         args : typing.Sequence<+T_co>[~UnitNetworkConfig]<~UnitNetworkConfig>
7277         '''
7278         self.args = [UnitNetworkConfig.from_json(o) for o in args or []]
7279
7280
7281
7282 class UnsetModelDefaults(Type):
7283     _toSchema = {'keys': 'keys'}
7284     _toPy = {'keys': 'keys'}
7285     def __init__(self, keys=None):
7286         '''
7287         keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
7288         '''
7289         self.keys = [ModelUnsetKeys.from_json(o) for o in keys or []]
7290
7291
7292
7293 class UpdateBehavior(Type):
7294     _toSchema = {'enable_os_refresh_update': 'enable-os-refresh-update', 'enable_os_upgrade': 'enable-os-upgrade'}
7295     _toPy = {'enable-os-refresh-update': 'enable_os_refresh_update', 'enable-os-upgrade': 'enable_os_upgrade'}
7296     def __init__(self, enable_os_refresh_update=None, enable_os_upgrade=None):
7297         '''
7298         enable_os_refresh_update : bool
7299         enable_os_upgrade : bool
7300         '''
7301         self.enable_os_refresh_update = enable_os_refresh_update
7302         self.enable_os_upgrade = enable_os_upgrade
7303
7304
7305
7306 class UpdateCloudCredential(Type):
7307     _toSchema = {'credential': 'credential', 'tag': 'tag'}
7308     _toPy = {'credential': 'credential', 'tag': 'tag'}
7309     def __init__(self, credential=None, tag=None):
7310         '''
7311         credential : CloudCredential
7312         tag : str
7313         '''
7314         self.credential = CloudCredential.from_json(credential) if credential else None
7315         self.tag = tag
7316
7317
7318
7319 class UpdateCloudCredentials(Type):
7320     _toSchema = {'credentials': 'credentials'}
7321     _toPy = {'credentials': 'credentials'}
7322     def __init__(self, credentials=None):
7323         '''
7324         credentials : typing.Sequence<+T_co>[~UpdateCloudCredential]<~UpdateCloudCredential>
7325         '''
7326         self.credentials = [UpdateCloudCredential.from_json(o) for o in credentials or []]
7327
7328
7329
7330 class UpgradeMongoParams(Type):
7331     _toSchema = {'target': 'target'}
7332     _toPy = {'target': 'target'}
7333     def __init__(self, target=None):
7334         '''
7335         target : MongoVersion
7336         '''
7337         self.target = MongoVersion.from_json(target) if target else None
7338
7339
7340
7341 class UserAccess(Type):
7342     _toSchema = {'access': 'access', 'user_tag': 'user-tag'}
7343     _toPy = {'access': 'access', 'user-tag': 'user_tag'}
7344     def __init__(self, access=None, user_tag=None):
7345         '''
7346         access : str
7347         user_tag : str
7348         '''
7349         self.access = access
7350         self.user_tag = user_tag
7351
7352
7353
7354 class UserAccessResult(Type):
7355     _toSchema = {'error': 'error', 'result': 'result'}
7356     _toPy = {'error': 'error', 'result': 'result'}
7357     def __init__(self, error=None, result=None):
7358         '''
7359         error : Error
7360         result : UserAccess
7361         '''
7362         self.error = Error.from_json(error) if error else None
7363         self.result = UserAccess.from_json(result) if result else None
7364
7365
7366
7367 class UserAccessResults(Type):
7368     _toSchema = {'results': 'results'}
7369     _toPy = {'results': 'results'}
7370     def __init__(self, results=None):
7371         '''
7372         results : typing.Sequence<+T_co>[~UserAccessResult]<~UserAccessResult>
7373         '''
7374         self.results = [UserAccessResult.from_json(o) for o in results or []]
7375
7376
7377
7378 class UserCloud(Type):
7379     _toSchema = {'cloud_tag': 'cloud-tag', 'user_tag': 'user-tag'}
7380     _toPy = {'cloud-tag': 'cloud_tag', 'user-tag': 'user_tag'}
7381     def __init__(self, cloud_tag=None, user_tag=None):
7382         '''
7383         cloud_tag : str
7384         user_tag : str
7385         '''
7386         self.cloud_tag = cloud_tag
7387         self.user_tag = user_tag
7388
7389
7390
7391 class UserClouds(Type):
7392     _toSchema = {'user_clouds': 'user-clouds'}
7393     _toPy = {'user-clouds': 'user_clouds'}
7394     def __init__(self, user_clouds=None):
7395         '''
7396         user_clouds : typing.Sequence<+T_co>[~UserCloud]<~UserCloud>
7397         '''
7398         self.user_clouds = [UserCloud.from_json(o) for o in user_clouds or []]
7399
7400
7401
7402 class UserInfo(Type):
7403     _toSchema = {'access': 'access', 'created_by': 'created-by', 'date_created': 'date-created', 'disabled': 'disabled', 'display_name': 'display-name', 'last_connection': 'last-connection', 'username': 'username'}
7404     _toPy = {'access': 'access', 'created-by': 'created_by', 'date-created': 'date_created', 'disabled': 'disabled', 'display-name': 'display_name', 'last-connection': 'last_connection', 'username': 'username'}
7405     def __init__(self, access=None, created_by=None, date_created=None, disabled=None, display_name=None, last_connection=None, username=None):
7406         '''
7407         access : str
7408         created_by : str
7409         date_created : str
7410         disabled : bool
7411         display_name : str
7412         last_connection : str
7413         username : str
7414         '''
7415         self.access = access
7416         self.created_by = created_by
7417         self.date_created = date_created
7418         self.disabled = disabled
7419         self.display_name = display_name
7420         self.last_connection = last_connection
7421         self.username = username
7422
7423
7424
7425 class UserInfoRequest(Type):
7426     _toSchema = {'entities': 'entities', 'include_disabled': 'include-disabled'}
7427     _toPy = {'entities': 'entities', 'include-disabled': 'include_disabled'}
7428     def __init__(self, entities=None, include_disabled=None):
7429         '''
7430         entities : typing.Sequence<+T_co>[~Entity]<~Entity>
7431         include_disabled : bool
7432         '''
7433         self.entities = [Entity.from_json(o) for o in entities or []]
7434         self.include_disabled = include_disabled
7435
7436
7437
7438 class UserInfoResult(Type):
7439     _toSchema = {'error': 'error', 'result': 'result'}
7440     _toPy = {'error': 'error', 'result': 'result'}
7441     def __init__(self, error=None, result=None):
7442         '''
7443         error : Error
7444         result : UserInfo
7445         '''
7446         self.error = Error.from_json(error) if error else None
7447         self.result = UserInfo.from_json(result) if result else None
7448
7449
7450
7451 class UserInfoResults(Type):
7452     _toSchema = {'results': 'results'}
7453     _toPy = {'results': 'results'}
7454     def __init__(self, results=None):
7455         '''
7456         results : typing.Sequence<+T_co>[~UserInfoResult]<~UserInfoResult>
7457         '''
7458         self.results = [UserInfoResult.from_json(o) for o in results or []]
7459
7460
7461
7462 class UserModel(Type):
7463     _toSchema = {'last_connection': 'last-connection', 'model': 'model'}
7464     _toPy = {'last-connection': 'last_connection', 'model': 'model'}
7465     def __init__(self, last_connection=None, model=None):
7466         '''
7467         last_connection : str
7468         model : Model
7469         '''
7470         self.last_connection = last_connection
7471         self.model = Model.from_json(model) if model else None
7472
7473
7474
7475 class UserModelList(Type):
7476     _toSchema = {'user_models': 'user-models'}
7477     _toPy = {'user-models': 'user_models'}
7478     def __init__(self, user_models=None):
7479         '''
7480         user_models : typing.Sequence<+T_co>[~UserModel]<~UserModel>
7481         '''
7482         self.user_models = [UserModel.from_json(o) for o in user_models or []]
7483
7484
7485
7486 class Value(Type):
7487     _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'}
7488     _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'}
7489     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):
7490         '''
7491         arch : str
7492         container : str
7493         cores : int
7494         cpu_power : int
7495         instance_type : str
7496         mem : int
7497         root_disk : int
7498         spaces : typing.Sequence<+T_co>[str]
7499         tags : typing.Sequence<+T_co>[str]
7500         virt_type : str
7501         '''
7502         self.arch = arch
7503         self.container = container
7504         self.cores = cores
7505         self.cpu_power = cpu_power
7506         self.instance_type = instance_type
7507         self.mem = mem
7508         self.root_disk = root_disk
7509         self.spaces = spaces
7510         self.tags = tags
7511         self.virt_type = virt_type
7512
7513
7514
7515 class Version(Type):
7516     _toSchema = {'version': 'version'}
7517     _toPy = {'version': 'version'}
7518     def __init__(self, version=None):
7519         '''
7520         version : Binary
7521         '''
7522         self.version = Binary.from_json(version) if version else None
7523
7524
7525
7526 class VersionResult(Type):
7527     _toSchema = {'error': 'error', 'version': 'version'}
7528     _toPy = {'error': 'error', 'version': 'version'}
7529     def __init__(self, error=None, version=None):
7530         '''
7531         error : Error
7532         version : Number
7533         '''
7534         self.error = Error.from_json(error) if error else None
7535         self.version = Number.from_json(version) if version else None
7536
7537
7538
7539 class VersionResults(Type):
7540     _toSchema = {'results': 'results'}
7541     _toPy = {'results': 'results'}
7542     def __init__(self, results=None):
7543         '''
7544         results : typing.Sequence<+T_co>[~VersionResult]<~VersionResult>
7545         '''
7546         self.results = [VersionResult.from_json(o) for o in results or []]
7547
7548
7549
7550 class Volume(Type):
7551     _toSchema = {'info': 'info', 'volume_tag': 'volume-tag'}
7552     _toPy = {'info': 'info', 'volume-tag': 'volume_tag'}
7553     def __init__(self, info=None, volume_tag=None):
7554         '''
7555         info : VolumeInfo
7556         volume_tag : str
7557         '''
7558         self.info = VolumeInfo.from_json(info) if info else None
7559         self.volume_tag = volume_tag
7560
7561
7562
7563 class VolumeAttachment(Type):
7564     _toSchema = {'info': 'info', 'machine_tag': 'machine-tag', 'volume_tag': 'volume-tag'}
7565     _toPy = {'info': 'info', 'machine-tag': 'machine_tag', 'volume-tag': 'volume_tag'}
7566     def __init__(self, info=None, machine_tag=None, volume_tag=None):
7567         '''
7568         info : VolumeAttachmentInfo
7569         machine_tag : str
7570         volume_tag : str
7571         '''
7572         self.info = VolumeAttachmentInfo.from_json(info) if info else None
7573         self.machine_tag = machine_tag
7574         self.volume_tag = volume_tag
7575
7576
7577
7578 class VolumeAttachmentDetails(Type):
7579     _toSchema = {'life': 'life', 'volumeattachmentinfo': 'VolumeAttachmentInfo'}
7580     _toPy = {'VolumeAttachmentInfo': 'volumeattachmentinfo', 'life': 'life'}
7581     def __init__(self, volumeattachmentinfo=None, life=None):
7582         '''
7583         volumeattachmentinfo : VolumeAttachmentInfo
7584         life : str
7585         '''
7586         self.volumeattachmentinfo = VolumeAttachmentInfo.from_json(volumeattachmentinfo) if volumeattachmentinfo else None
7587         self.life = life
7588
7589
7590
7591 class VolumeAttachmentInfo(Type):
7592     _toSchema = {'bus_address': 'bus-address', 'device_link': 'device-link', 'device_name': 'device-name', 'read_only': 'read-only'}
7593     _toPy = {'bus-address': 'bus_address', 'device-link': 'device_link', 'device-name': 'device_name', 'read-only': 'read_only'}
7594     def __init__(self, bus_address=None, device_link=None, device_name=None, read_only=None):
7595         '''
7596         bus_address : str
7597         device_link : str
7598         device_name : str
7599         read_only : bool
7600         '''
7601         self.bus_address = bus_address
7602         self.device_link = device_link
7603         self.device_name = device_name
7604         self.read_only = read_only
7605
7606
7607
7608 class VolumeAttachmentParams(Type):
7609     _toSchema = {'instance_id': 'instance-id', 'machine_tag': 'machine-tag', 'provider': 'provider', 'read_only': 'read-only', 'volume_id': 'volume-id', 'volume_tag': 'volume-tag'}
7610     _toPy = {'instance-id': 'instance_id', 'machine-tag': 'machine_tag', 'provider': 'provider', 'read-only': 'read_only', 'volume-id': 'volume_id', 'volume-tag': 'volume_tag'}
7611     def __init__(self, instance_id=None, machine_tag=None, provider=None, read_only=None, volume_id=None, volume_tag=None):
7612         '''
7613         instance_id : str
7614         machine_tag : str
7615         provider : str
7616         read_only : bool
7617         volume_id : str
7618         volume_tag : str
7619         '''
7620         self.instance_id = instance_id
7621         self.machine_tag = machine_tag
7622         self.provider = provider
7623         self.read_only = read_only
7624         self.volume_id = volume_id
7625         self.volume_tag = volume_tag
7626
7627
7628
7629 class VolumeAttachmentParamsResult(Type):
7630     _toSchema = {'error': 'error', 'result': 'result'}
7631     _toPy = {'error': 'error', 'result': 'result'}
7632     def __init__(self, error=None, result=None):
7633         '''
7634         error : Error
7635         result : VolumeAttachmentParams
7636         '''
7637         self.error = Error.from_json(error) if error else None
7638         self.result = VolumeAttachmentParams.from_json(result) if result else None
7639
7640
7641
7642 class VolumeAttachmentParamsResults(Type):
7643     _toSchema = {'results': 'results'}
7644     _toPy = {'results': 'results'}
7645     def __init__(self, results=None):
7646         '''
7647         results : typing.Sequence<+T_co>[~VolumeAttachmentParamsResult]<~VolumeAttachmentParamsResult>
7648         '''
7649         self.results = [VolumeAttachmentParamsResult.from_json(o) for o in results or []]
7650
7651
7652
7653 class VolumeAttachmentResult(Type):
7654     _toSchema = {'error': 'error', 'result': 'result'}
7655     _toPy = {'error': 'error', 'result': 'result'}
7656     def __init__(self, error=None, result=None):
7657         '''
7658         error : Error
7659         result : VolumeAttachment
7660         '''
7661         self.error = Error.from_json(error) if error else None
7662         self.result = VolumeAttachment.from_json(result) if result else None
7663
7664
7665
7666 class VolumeAttachmentResults(Type):
7667     _toSchema = {'results': 'results'}
7668     _toPy = {'results': 'results'}
7669     def __init__(self, results=None):
7670         '''
7671         results : typing.Sequence<+T_co>[~VolumeAttachmentResult]<~VolumeAttachmentResult>
7672         '''
7673         self.results = [VolumeAttachmentResult.from_json(o) for o in results or []]
7674
7675
7676
7677 class VolumeAttachments(Type):
7678     _toSchema = {'volume_attachments': 'volume-attachments'}
7679     _toPy = {'volume-attachments': 'volume_attachments'}
7680     def __init__(self, volume_attachments=None):
7681         '''
7682         volume_attachments : typing.Sequence<+T_co>[~VolumeAttachment]<~VolumeAttachment>
7683         '''
7684         self.volume_attachments = [VolumeAttachment.from_json(o) for o in volume_attachments or []]
7685
7686
7687
7688 class VolumeDetails(Type):
7689     _toSchema = {'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'volume_tag': 'volume-tag'}
7690     _toPy = {'info': 'info', 'machine-attachments': 'machine_attachments', 'status': 'status', 'storage': 'storage', 'volume-tag': 'volume_tag'}
7691     def __init__(self, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None):
7692         '''
7693         info : VolumeInfo
7694         machine_attachments : typing.Mapping<~KT, +VT_co>[str, ~VolumeAttachmentInfo]<~VolumeAttachmentInfo>
7695         status : EntityStatus
7696         storage : StorageDetails
7697         volume_tag : str
7698         '''
7699         self.info = VolumeInfo.from_json(info) if info else None
7700         self.machine_attachments = machine_attachments
7701         self.status = EntityStatus.from_json(status) if status else None
7702         self.storage = StorageDetails.from_json(storage) if storage else None
7703         self.volume_tag = volume_tag
7704
7705
7706
7707 class VolumeDetailsListResult(Type):
7708     _toSchema = {'error': 'error', 'result': 'result'}
7709     _toPy = {'error': 'error', 'result': 'result'}
7710     def __init__(self, error=None, result=None):
7711         '''
7712         error : Error
7713         result : typing.Sequence<+T_co>[~VolumeDetails]<~VolumeDetails>
7714         '''
7715         self.error = Error.from_json(error) if error else None
7716         self.result = [VolumeDetails.from_json(o) for o in result or []]
7717
7718
7719
7720 class VolumeDetailsListResults(Type):
7721     _toSchema = {'results': 'results'}
7722     _toPy = {'results': 'results'}
7723     def __init__(self, results=None):
7724         '''
7725         results : typing.Sequence<+T_co>[~VolumeDetailsListResult]<~VolumeDetailsListResult>
7726         '''
7727         self.results = [VolumeDetailsListResult.from_json(o) for o in results or []]
7728
7729
7730
7731 class VolumeFilter(Type):
7732     _toSchema = {'machines': 'machines'}
7733     _toPy = {'machines': 'machines'}
7734     def __init__(self, machines=None):
7735         '''
7736         machines : typing.Sequence<+T_co>[str]
7737         '''
7738         self.machines = machines
7739
7740
7741
7742 class VolumeFilters(Type):
7743     _toSchema = {'filters': 'filters'}
7744     _toPy = {'filters': 'filters'}
7745     def __init__(self, filters=None):
7746         '''
7747         filters : typing.Sequence<+T_co>[~VolumeFilter]<~VolumeFilter>
7748         '''
7749         self.filters = [VolumeFilter.from_json(o) for o in filters or []]
7750
7751
7752
7753 class VolumeInfo(Type):
7754     _toSchema = {'hardware_id': 'hardware-id', 'persistent': 'persistent', 'size': 'size', 'volume_id': 'volume-id'}
7755     _toPy = {'hardware-id': 'hardware_id', 'persistent': 'persistent', 'size': 'size', 'volume-id': 'volume_id'}
7756     def __init__(self, hardware_id=None, persistent=None, size=None, volume_id=None):
7757         '''
7758         hardware_id : str
7759         persistent : bool
7760         size : int
7761         volume_id : str
7762         '''
7763         self.hardware_id = hardware_id
7764         self.persistent = persistent
7765         self.size = size
7766         self.volume_id = volume_id
7767
7768
7769
7770 class VolumeParams(Type):
7771     _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume_tag': 'volume-tag'}
7772     _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume-tag': 'volume_tag'}
7773     def __init__(self, attachment=None, attributes=None, provider=None, size=None, tags=None, volume_tag=None):
7774         '''
7775         attachment : VolumeAttachmentParams
7776         attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
7777         provider : str
7778         size : int
7779         tags : typing.Mapping<~KT, +VT_co>[str, str]
7780         volume_tag : str
7781         '''
7782         self.attachment = VolumeAttachmentParams.from_json(attachment) if attachment else None
7783         self.attributes = attributes
7784         self.provider = provider
7785         self.size = size
7786         self.tags = tags
7787         self.volume_tag = volume_tag
7788
7789
7790
7791 class VolumeParamsResult(Type):
7792     _toSchema = {'error': 'error', 'result': 'result'}
7793     _toPy = {'error': 'error', 'result': 'result'}
7794     def __init__(self, error=None, result=None):
7795         '''
7796         error : Error
7797         result : VolumeParams
7798         '''
7799         self.error = Error.from_json(error) if error else None
7800         self.result = VolumeParams.from_json(result) if result else None
7801
7802
7803
7804 class VolumeParamsResults(Type):
7805     _toSchema = {'results': 'results'}
7806     _toPy = {'results': 'results'}
7807     def __init__(self, results=None):
7808         '''
7809         results : typing.Sequence<+T_co>[~VolumeParamsResult]<~VolumeParamsResult>
7810         '''
7811         self.results = [VolumeParamsResult.from_json(o) for o in results or []]
7812
7813
7814
7815 class VolumeResult(Type):
7816     _toSchema = {'error': 'error', 'result': 'result'}
7817     _toPy = {'error': 'error', 'result': 'result'}
7818     def __init__(self, error=None, result=None):
7819         '''
7820         error : Error
7821         result : Volume
7822         '''
7823         self.error = Error.from_json(error) if error else None
7824         self.result = Volume.from_json(result) if result else None
7825
7826
7827
7828 class VolumeResults(Type):
7829     _toSchema = {'results': 'results'}
7830     _toPy = {'results': 'results'}
7831     def __init__(self, results=None):
7832         '''
7833         results : typing.Sequence<+T_co>[~VolumeResult]<~VolumeResult>
7834         '''
7835         self.results = [VolumeResult.from_json(o) for o in results or []]
7836
7837
7838
7839 class Volumes(Type):
7840     _toSchema = {'volumes': 'volumes'}
7841     _toPy = {'volumes': 'volumes'}
7842     def __init__(self, volumes=None):
7843         '''
7844         volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
7845         '''
7846         self.volumes = [Volume.from_json(o) for o in volumes or []]
7847
7848
7849
7850 class WatchContainer(Type):
7851     _toSchema = {'container_type': 'container-type', 'machine_tag': 'machine-tag'}
7852     _toPy = {'container-type': 'container_type', 'machine-tag': 'machine_tag'}
7853     def __init__(self, container_type=None, machine_tag=None):
7854         '''
7855         container_type : str
7856         machine_tag : str
7857         '''
7858         self.container_type = container_type
7859         self.machine_tag = machine_tag
7860
7861
7862
7863 class WatchContainers(Type):
7864     _toSchema = {'params': 'params'}
7865     _toPy = {'params': 'params'}
7866     def __init__(self, params=None):
7867         '''
7868         params : typing.Sequence<+T_co>[~WatchContainer]<~WatchContainer>
7869         '''
7870         self.params = [WatchContainer.from_json(o) for o in params or []]
7871
7872
7873
7874 class ZoneResult(Type):
7875     _toSchema = {'available': 'available', 'error': 'error', 'name': 'name'}
7876     _toPy = {'available': 'available', 'error': 'error', 'name': 'name'}
7877     def __init__(self, available=None, error=None, name=None):
7878         '''
7879         available : bool
7880         error : Error
7881         name : str
7882         '''
7883         self.available = available
7884         self.error = Error.from_json(error) if error else None
7885         self.name = name
7886
7887
7888
7889 class ZoneResults(Type):
7890     _toSchema = {'results': 'results'}
7891     _toPy = {'results': 'results'}
7892     def __init__(self, results=None):
7893         '''
7894         results : typing.Sequence<+T_co>[~ZoneResult]<~ZoneResult>
7895         '''
7896         self.results = [ZoneResult.from_json(o) for o in results or []]
7897
7898