juju/client/_definitions.py

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