modules/libjuju/juju/client/_definitions.py

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