X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=modules%2Flibjuju%2Fjuju%2Fclient%2F_definitions.py;h=2d25e3920c7bb705f8a2b6fe8f3f6e4b9437358b;hp=fde035f50808784cea0a4fa6a2319ebe6acba67d;hb=b2a07f566be558a8b59b8b5dedfe8da5ae1b0132;hpb=c3e6c2ec9a1fddfc8e9bd31509b366e633b6d99e

diff --git a/modules/libjuju/juju/client/_definitions.py b/modules/libjuju/juju/client/_definitions.py
index fde035f..2d25e39 100644
--- a/modules/libjuju/juju/client/_definitions.py
+++ b/modules/libjuju/juju/client/_definitions.py
@@ -9,7 +9,7 @@ class APIHostPortsResult(Type):
     _toPy = {'servers': 'servers'}
     def __init__(self, servers=None, **unknown_fields):
         '''
-        servers : typing.Sequence<+T_co>[~HostPort]<~HostPort>
+        servers : typing.Sequence[~HostPort]
         '''
         self.servers = [HostPort.from_json(o) for o in servers or []]
 
@@ -21,7 +21,7 @@ class Action(Type):
     def __init__(self, name=None, parameters=None, receiver=None, tag=None, **unknown_fields):
         '''
         name : str
-        parameters : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        parameters : typing.Mapping[str, typing.Any]
         receiver : str
         tag : str
         '''
@@ -39,7 +39,7 @@ class ActionExecutionResult(Type):
         '''
         action_tag : str
         message : str
-        results : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        results : typing.Mapping[str, typing.Any]
         status : str
         '''
         self.action_tag = action_tag
@@ -54,12 +54,25 @@ class ActionExecutionResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ActionExecutionResult]<~ActionExecutionResult>
+        results : typing.Sequence[~ActionExecutionResult]
         '''
         self.results = [ActionExecutionResult.from_json(o) for o in results or []]
 
 
 
+class ActionPruneArgs(Type):
+    _toSchema = {'max_history_mb': 'max-history-mb', 'max_history_time': 'max-history-time'}
+    _toPy = {'max-history-mb': 'max_history_mb', 'max-history-time': 'max_history_time'}
+    def __init__(self, max_history_mb=None, max_history_time=None, **unknown_fields):
+        '''
+        max_history_mb : int
+        max_history_time : int
+        '''
+        self.max_history_mb = max_history_mb
+        self.max_history_time = max_history_time
+
+
+
 class ActionResult(Type):
     _toSchema = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
     _toPy = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
@@ -70,7 +83,7 @@ class ActionResult(Type):
         enqueued : str
         error : Error
         message : str
-        output : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        output : typing.Mapping[str, typing.Any]
         started : str
         status : str
         '''
@@ -90,7 +103,7 @@ class ActionResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
+        results : typing.Sequence[~ActionResult]
         '''
         self.results = [ActionResult.from_json(o) for o in results or []]
 
@@ -102,7 +115,7 @@ class ActionSpec(Type):
     def __init__(self, description=None, params=None, **unknown_fields):
         '''
         description : str
-        params : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        params : typing.Mapping[str, typing.Any]
         '''
         self.description = description
         self.params = params
@@ -114,7 +127,7 @@ class Actions(Type):
     _toPy = {'actions': 'actions'}
     def __init__(self, actions=None, **unknown_fields):
         '''
-        actions : typing.Sequence<+T_co>[~Action]<~Action>
+        actions : typing.Sequence[~Action]
         '''
         self.actions = [Action.from_json(o) for o in actions or []]
 
@@ -125,7 +138,7 @@ class ActionsByName(Type):
     _toPy = {'actions': 'actions', 'error': 'error', 'name': 'name'}
     def __init__(self, actions=None, error=None, name=None, **unknown_fields):
         '''
-        actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
+        actions : typing.Sequence[~ActionResult]
         error : Error
         name : str
         '''
@@ -140,7 +153,7 @@ class ActionsByNames(Type):
     _toPy = {'actions': 'actions'}
     def __init__(self, actions=None, **unknown_fields):
         '''
-        actions : typing.Sequence<+T_co>[~ActionsByName]<~ActionsByName>
+        actions : typing.Sequence[~ActionsByName]
         '''
         self.actions = [ActionsByName.from_json(o) for o in actions or []]
 
@@ -151,7 +164,7 @@ class ActionsByReceiver(Type):
     _toPy = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
     def __init__(self, actions=None, error=None, receiver=None, **unknown_fields):
         '''
-        actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
+        actions : typing.Sequence[~ActionResult]
         error : Error
         receiver : str
         '''
@@ -166,12 +179,42 @@ class ActionsByReceivers(Type):
     _toPy = {'actions': 'actions'}
     def __init__(self, actions=None, **unknown_fields):
         '''
-        actions : typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
+        actions : typing.Sequence[~ActionsByReceiver]
         '''
         self.actions = [ActionsByReceiver.from_json(o) for o in actions or []]
 
 
 
+class AddApplicationOffer(Type):
+    _toSchema = {'application_description': 'application-description', 'application_name': 'application-name', 'endpoints': 'endpoints', 'model_tag': 'model-tag', 'offer_name': 'offer-name'}
+    _toPy = {'application-description': 'application_description', 'application-name': 'application_name', 'endpoints': 'endpoints', 'model-tag': 'model_tag', 'offer-name': 'offer_name'}
+    def __init__(self, application_description=None, application_name=None, endpoints=None, model_tag=None, offer_name=None, **unknown_fields):
+        '''
+        application_description : str
+        application_name : str
+        endpoints : typing.Mapping[str, str]
+        model_tag : str
+        offer_name : str
+        '''
+        self.application_description = application_description
+        self.application_name = application_name
+        self.endpoints = endpoints
+        self.model_tag = model_tag
+        self.offer_name = offer_name
+
+
+
+class AddApplicationOffers(Type):
+    _toSchema = {'offers': 'Offers'}
+    _toPy = {'Offers': 'offers'}
+    def __init__(self, offers=None, **unknown_fields):
+        '''
+        offers : typing.Sequence[~AddApplicationOffer]
+        '''
+        self.offers = [AddApplicationOffer.from_json(o) for o in offers or []]
+
+
+
 class AddApplicationUnits(Type):
     _toSchema = {'application': 'application', 'num_units': 'num-units', 'placement': 'placement'}
     _toPy = {'application': 'application', 'num-units': 'num_units', 'placement': 'placement'}
@@ -179,7 +222,7 @@ class AddApplicationUnits(Type):
         '''
         application : str
         num_units : int
-        placement : typing.Sequence<+T_co>[~Placement]<~Placement>
+        placement : typing.Sequence[~Placement]
         '''
         self.application = application
         self.num_units = num_units
@@ -192,7 +235,7 @@ class AddApplicationUnitsResults(Type):
     _toPy = {'units': 'units'}
     def __init__(self, units=None, **unknown_fields):
         '''
-        units : typing.Sequence<+T_co>[str]
+        units : typing.Sequence[str]
         '''
         self.units = units
 
@@ -226,18 +269,31 @@ class AddCharmWithAuthorization(Type):
 
 
 
+class AddCloudArgs(Type):
+    _toSchema = {'cloud': 'cloud', 'name': 'name'}
+    _toPy = {'cloud': 'cloud', 'name': 'name'}
+    def __init__(self, cloud=None, name=None, **unknown_fields):
+        '''
+        cloud : Cloud
+        name : str
+        '''
+        self.cloud = Cloud.from_json(cloud) if cloud else None
+        self.name = name
+
+
+
 class AddMachineParams(Type):
     _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'}
     _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'}
     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):
         '''
-        addresses : typing.Sequence<+T_co>[~Address]<~Address>
+        addresses : typing.Sequence[~Address]
         constraints : Value
         container_type : str
-        disks : typing.Sequence<+T_co>[~Constraints]<~Constraints>
+        disks : typing.Sequence[~Constraints]
         hardware_characteristics : HardwareCharacteristics
         instance_id : str
-        jobs : typing.Sequence<+T_co>[str]
+        jobs : typing.Sequence[str]
         nonce : str
         parent_id : str
         placement : Placement
@@ -262,7 +318,7 @@ class AddMachines(Type):
     _toPy = {'params': 'params'}
     def __init__(self, params=None, **unknown_fields):
         '''
-        params : typing.Sequence<+T_co>[~AddMachineParams]<~AddMachineParams>
+        params : typing.Sequence[~AddMachineParams]
         '''
         self.params = [AddMachineParams.from_json(o) for o in params or []]
 
@@ -286,7 +342,7 @@ class AddMachinesResults(Type):
     _toPy = {'machines': 'machines'}
     def __init__(self, machines=None, **unknown_fields):
         '''
-        machines : typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
+        machines : typing.Sequence[~AddMachinesResult]
         '''
         self.machines = [AddMachinesResult.from_json(o) for o in machines or []]
 
@@ -299,7 +355,7 @@ class AddPendingResourcesArgs(Type):
         '''
         addcharmwithauthorization : AddCharmWithAuthorization
         entity : Entity
-        resources : typing.Sequence<+T_co>[~CharmResource]<~CharmResource>
+        resources : typing.Sequence[~CharmResource]
         '''
         self.addcharmwithauthorization = AddCharmWithAuthorization.from_json(addcharmwithauthorization) if addcharmwithauthorization else None
         self.entity = Entity.from_json(entity) if entity else None
@@ -313,7 +369,7 @@ class AddPendingResourcesResult(Type):
     def __init__(self, errorresult=None, pending_ids=None, **unknown_fields):
         '''
         errorresult : ErrorResult
-        pending_ids : typing.Sequence<+T_co>[str]
+        pending_ids : typing.Sequence[str]
         '''
         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
         self.pending_ids = pending_ids
@@ -325,7 +381,7 @@ class AddRelation(Type):
     _toPy = {'endpoints': 'endpoints'}
     def __init__(self, endpoints=None, **unknown_fields):
         '''
-        endpoints : typing.Sequence<+T_co>[str]
+        endpoints : typing.Sequence[str]
         '''
         self.endpoints = endpoints
 
@@ -336,12 +392,47 @@ class AddRelationResults(Type):
     _toPy = {'endpoints': 'endpoints'}
     def __init__(self, endpoints=None, **unknown_fields):
         '''
-        endpoints : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
+        endpoints : typing.Mapping[str, ~CharmRelation]
         '''
         self.endpoints = endpoints
 
 
 
+class AddStorageDetails(Type):
+    _toSchema = {'storage_tags': 'storage-tags'}
+    _toPy = {'storage-tags': 'storage_tags'}
+    def __init__(self, storage_tags=None, **unknown_fields):
+        '''
+        storage_tags : typing.Sequence[str]
+        '''
+        self.storage_tags = storage_tags
+
+
+
+class AddStorageResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : AddStorageDetails
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = AddStorageDetails.from_json(result) if result else None
+
+
+
+class AddStorageResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~AddStorageResult]
+        '''
+        self.results = [AddStorageResult.from_json(o) for o in results or []]
+
+
+
 class AddSubnetParams(Type):
     _toSchema = {'space_tag': 'space-tag', 'subnet_provider_id': 'subnet-provider-id', 'subnet_tag': 'subnet-tag', 'zones': 'zones'}
     _toPy = {'space-tag': 'space_tag', 'subnet-provider-id': 'subnet_provider_id', 'subnet-tag': 'subnet_tag', 'zones': 'zones'}
@@ -350,7 +441,7 @@ class AddSubnetParams(Type):
         space_tag : str
         subnet_provider_id : str
         subnet_tag : str
-        zones : typing.Sequence<+T_co>[str]
+        zones : typing.Sequence[str]
         '''
         self.space_tag = space_tag
         self.subnet_provider_id = subnet_provider_id
@@ -364,7 +455,7 @@ class AddSubnetsParams(Type):
     _toPy = {'subnets': 'subnets'}
     def __init__(self, subnets=None, **unknown_fields):
         '''
-        subnets : typing.Sequence<+T_co>[~AddSubnetParams]<~AddSubnetParams>
+        subnets : typing.Sequence[~AddSubnetParams]
         '''
         self.subnets = [AddSubnetParams.from_json(o) for o in subnets or []]
 
@@ -391,7 +482,7 @@ class AddUserResult(Type):
     def __init__(self, error=None, secret_key=None, tag=None, **unknown_fields):
         '''
         error : Error
-        secret_key : typing.Sequence<+T_co>[int]
+        secret_key : typing.Sequence[int]
         tag : str
         '''
         self.error = Error.from_json(error) if error else None
@@ -405,7 +496,7 @@ class AddUserResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~AddUserResult]<~AddUserResult>
+        results : typing.Sequence[~AddUserResult]
         '''
         self.results = [AddUserResult.from_json(o) for o in results or []]
 
@@ -416,7 +507,7 @@ class AddUsers(Type):
     _toPy = {'users': 'users'}
     def __init__(self, users=None, **unknown_fields):
         '''
-        users : typing.Sequence<+T_co>[~AddUser]<~AddUser>
+        users : typing.Sequence[~AddUser]
         '''
         self.users = [AddUser.from_json(o) for o in users or []]
 
@@ -459,7 +550,7 @@ class AgentGetEntitiesResult(Type):
         '''
         container_type : str
         error : Error
-        jobs : typing.Sequence<+T_co>[str]
+        jobs : typing.Sequence[str]
         life : str
         '''
         self.container_type = container_type
@@ -474,7 +565,7 @@ class AgentGetEntitiesResults(Type):
     _toPy = {'entities': 'entities'}
     def __init__(self, entities=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~AgentGetEntitiesResult]<~AgentGetEntitiesResult>
+        entities : typing.Sequence[~AgentGetEntitiesResult]
         '''
         self.entities = [AgentGetEntitiesResult.from_json(o) for o in entities or []]
 
@@ -507,7 +598,7 @@ class AllWatcherNextResults(Type):
     _toPy = {'deltas': 'deltas'}
     def __init__(self, deltas=None, **unknown_fields):
         '''
-        deltas : typing.Sequence<+T_co>[~Delta]<~Delta>
+        deltas : typing.Sequence[~Delta]
         '''
         self.deltas = [Delta.from_json(o) for o in deltas or []]
 
@@ -518,7 +609,7 @@ class AnnotationsGetResult(Type):
     _toPy = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
     def __init__(self, annotations=None, entity=None, error=None, **unknown_fields):
         '''
-        annotations : typing.Mapping<~KT, +VT_co>[str, str]
+        annotations : typing.Mapping[str, str]
         entity : str
         error : ErrorResult
         '''
@@ -533,7 +624,7 @@ class AnnotationsGetResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~AnnotationsGetResult]<~AnnotationsGetResult>
+        results : typing.Sequence[~AnnotationsGetResult]
         '''
         self.results = [AnnotationsGetResult.from_json(o) for o in results or []]
 
@@ -544,18 +635,35 @@ class AnnotationsSet(Type):
     _toPy = {'annotations': 'annotations'}
     def __init__(self, annotations=None, **unknown_fields):
         '''
-        annotations : typing.Sequence<+T_co>[~EntityAnnotations]<~EntityAnnotations>
+        annotations : typing.Sequence[~EntityAnnotations]
         '''
         self.annotations = [EntityAnnotations.from_json(o) for o in annotations or []]
 
 
 
+class ApplicationCharm(Type):
+    _toSchema = {'charm_modified_version': 'charm-modified-version', 'force_upgrade': 'force-upgrade', 'sha256': 'sha256', 'url': 'url'}
+    _toPy = {'charm-modified-version': 'charm_modified_version', 'force-upgrade': 'force_upgrade', 'sha256': 'sha256', 'url': 'url'}
+    def __init__(self, charm_modified_version=None, force_upgrade=None, sha256=None, url=None, **unknown_fields):
+        '''
+        charm_modified_version : int
+        force_upgrade : bool
+        sha256 : str
+        url : str
+        '''
+        self.charm_modified_version = charm_modified_version
+        self.force_upgrade = force_upgrade
+        self.sha256 = sha256
+        self.url = url
+
+
+
 class ApplicationCharmActionsResult(Type):
     _toSchema = {'actions': 'actions', 'application_tag': 'application-tag', 'error': 'error'}
     _toPy = {'actions': 'actions', 'application-tag': 'application_tag', 'error': 'error'}
     def __init__(self, actions=None, application_tag=None, error=None, **unknown_fields):
         '''
-        actions : typing.Mapping<~KT, +VT_co>[str, ~ActionSpec]<~ActionSpec>
+        actions : typing.Mapping[str, ~ActionSpec]
         application_tag : str
         error : Error
         '''
@@ -581,39 +689,117 @@ class ApplicationCharmRelationsResults(Type):
     _toPy = {'charm-relations': 'charm_relations'}
     def __init__(self, charm_relations=None, **unknown_fields):
         '''
-        charm_relations : typing.Sequence<+T_co>[str]
+        charm_relations : typing.Sequence[str]
         '''
         self.charm_relations = charm_relations
 
 
 
+class ApplicationCharmResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : ApplicationCharm
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = ApplicationCharm.from_json(result) if result else None
+
+
+
+class ApplicationCharmResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ApplicationCharmResult]
+        '''
+        self.results = [ApplicationCharmResult.from_json(o) for o in results or []]
+
+
+
+class ApplicationConfigSet(Type):
+    _toSchema = {'application': 'application', 'config': 'config'}
+    _toPy = {'application': 'application', 'config': 'config'}
+    def __init__(self, application=None, config=None, **unknown_fields):
+        '''
+        application : str
+        config : typing.Mapping[str, str]
+        '''
+        self.application = application
+        self.config = config
+
+
+
+class ApplicationConfigSetArgs(Type):
+    _toSchema = {'args': 'Args'}
+    _toPy = {'Args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~ApplicationConfigSet]
+        '''
+        self.args = [ApplicationConfigSet.from_json(o) for o in args or []]
+
+
+
+class ApplicationConfigUnsetArgs(Type):
+    _toSchema = {'args': 'Args'}
+    _toPy = {'Args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~ApplicationUnset]
+        '''
+        self.args = [ApplicationUnset.from_json(o) for o in args or []]
+
+
+
+class ApplicationConstraint(Type):
+    _toSchema = {'constraints': 'constraints', 'error': 'error'}
+    _toPy = {'constraints': 'constraints', 'error': 'error'}
+    def __init__(self, constraints=None, error=None, **unknown_fields):
+        '''
+        constraints : Value
+        error : Error
+        '''
+        self.constraints = Value.from_json(constraints) if constraints else None
+        self.error = Error.from_json(error) if error else None
+
+
+
 class ApplicationDeploy(Type):
-    _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'}
-    _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'}
-    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):
+    _toSchema = {'application': 'application', 'attach_storage': 'attach-storage', 'channel': 'channel', 'charm_url': 'charm-url', 'config': 'config', 'config_yaml': 'config-yaml', 'constraints': 'constraints', 'devices': 'devices', 'endpoint_bindings': 'endpoint-bindings', 'num_units': 'num-units', 'placement': 'placement', 'policy': 'policy', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
+    _toPy = {'application': 'application', 'attach-storage': 'attach_storage', 'channel': 'channel', 'charm-url': 'charm_url', 'config': 'config', 'config-yaml': 'config_yaml', 'constraints': 'constraints', 'devices': 'devices', 'endpoint-bindings': 'endpoint_bindings', 'num-units': 'num_units', 'placement': 'placement', 'policy': 'policy', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
+    def __init__(self, application=None, attach_storage=None, channel=None, charm_url=None, config=None, config_yaml=None, constraints=None, devices=None, endpoint_bindings=None, num_units=None, placement=None, policy=None, resources=None, series=None, storage=None, **unknown_fields):
         '''
         application : str
+        attach_storage : typing.Sequence[str]
         channel : str
         charm_url : str
-        config : typing.Mapping<~KT, +VT_co>[str, str]
+        config : typing.Mapping[str, str]
         config_yaml : str
         constraints : Value
-        endpoint_bindings : typing.Mapping<~KT, +VT_co>[str, str]
+        devices : typing.Mapping[str, ~Constraints]
+        endpoint_bindings : typing.Mapping[str, str]
         num_units : int
-        placement : typing.Sequence<+T_co>[~Placement]<~Placement>
-        resources : typing.Mapping<~KT, +VT_co>[str, str]
+        placement : typing.Sequence[~Placement]
+        policy : str
+        resources : typing.Mapping[str, str]
         series : str
-        storage : typing.Mapping<~KT, +VT_co>[str, ~Constraints]<~Constraints>
+        storage : typing.Mapping[str, ~Constraints]
         '''
         self.application = application
+        self.attach_storage = attach_storage
         self.channel = channel
         self.charm_url = charm_url
         self.config = config
         self.config_yaml = config_yaml
         self.constraints = Value.from_json(constraints) if constraints else None
+        self.devices = devices
         self.endpoint_bindings = endpoint_bindings
         self.num_units = num_units
         self.placement = [Placement.from_json(o) for o in placement or []]
+        self.policy = policy
         self.resources = resources
         self.series = series
         self.storage = storage
@@ -653,6 +839,28 @@ class ApplicationGet(Type):
 
 
 
+class ApplicationGetConfigResults(Type):
+    _toSchema = {'results': 'Results'}
+    _toPy = {'Results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ConfigResult]
+        '''
+        self.results = [ConfigResult.from_json(o) for o in results or []]
+
+
+
+class ApplicationGetConstraintsResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ApplicationConstraint]
+        '''
+        self.results = [ApplicationConstraint.from_json(o) for o in results or []]
+
+
+
 class ApplicationGetResults(Type):
     _toSchema = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
     _toPy = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
@@ -660,7 +868,7 @@ class ApplicationGetResults(Type):
         '''
         application : str
         charm : str
-        config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        config : typing.Mapping[str, typing.Any]
         constraints : Value
         series : str
         '''
@@ -678,7 +886,7 @@ class ApplicationMetricCredential(Type):
     def __init__(self, application=None, metrics_credentials=None, **unknown_fields):
         '''
         application : str
-        metrics_credentials : typing.Sequence<+T_co>[int]
+        metrics_credentials : typing.Sequence[int]
         '''
         self.application = application
         self.metrics_credentials = metrics_credentials
@@ -690,7 +898,7 @@ class ApplicationMetricCredentials(Type):
     _toPy = {'creds': 'creds'}
     def __init__(self, creds=None, **unknown_fields):
         '''
-        creds : typing.Sequence<+T_co>[~ApplicationMetricCredential]<~ApplicationMetricCredential>
+        creds : typing.Sequence[~ApplicationMetricCredential]
         '''
         self.creds = [ApplicationMetricCredential.from_json(o) for o in creds or []]
 
@@ -703,12 +911,12 @@ class ApplicationOffer(Type):
         '''
         access : str
         application_description : str
-        bindings : typing.Mapping<~KT, +VT_co>[str, str]
-        endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
+        bindings : typing.Mapping[str, str]
+        endpoints : typing.Sequence[~RemoteEndpoint]
         offer_name : str
         offer_url : str
         source_model_tag : str
-        spaces : typing.Sequence<+T_co>[~RemoteSpace]<~RemoteSpace>
+        spaces : typing.Sequence[~RemoteSpace]
         '''
         self.access = access
         self.application_description = application_description
@@ -721,13 +929,104 @@ class ApplicationOffer(Type):
 
 
 
+class ApplicationOfferAdminDetails(Type):
+    _toSchema = {'application_name': 'application-name', 'applicationofferdetails': 'ApplicationOfferDetails', 'charm_url': 'charm-url', 'connections': 'connections'}
+    _toPy = {'ApplicationOfferDetails': 'applicationofferdetails', 'application-name': 'application_name', 'charm-url': 'charm_url', 'connections': 'connections'}
+    def __init__(self, applicationofferdetails=None, application_name=None, charm_url=None, connections=None, **unknown_fields):
+        '''
+        applicationofferdetails : ApplicationOfferDetails
+        application_name : str
+        charm_url : str
+        connections : typing.Sequence[~OfferConnection]
+        '''
+        self.applicationofferdetails = ApplicationOfferDetails.from_json(applicationofferdetails) if applicationofferdetails else None
+        self.application_name = application_name
+        self.charm_url = charm_url
+        self.connections = [OfferConnection.from_json(o) for o in connections or []]
+
+
+
+class ApplicationOfferDetails(Type):
+    _toSchema = {'application_description': 'application-description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer_name': 'offer-name', 'offer_url': 'offer-url', 'offer_uuid': 'offer-uuid', 'source_model_tag': 'source-model-tag', 'spaces': 'spaces', 'users': 'users'}
+    _toPy = {'application-description': 'application_description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer-name': 'offer_name', 'offer-url': 'offer_url', 'offer-uuid': 'offer_uuid', 'source-model-tag': 'source_model_tag', 'spaces': 'spaces', 'users': 'users'}
+    def __init__(self, application_description=None, bindings=None, endpoints=None, offer_name=None, offer_url=None, offer_uuid=None, source_model_tag=None, spaces=None, users=None, **unknown_fields):
+        '''
+        application_description : str
+        bindings : typing.Mapping[str, str]
+        endpoints : typing.Sequence[~RemoteEndpoint]
+        offer_name : str
+        offer_url : str
+        offer_uuid : str
+        source_model_tag : str
+        spaces : typing.Sequence[~RemoteSpace]
+        users : typing.Sequence[~OfferUserDetails]
+        '''
+        self.application_description = application_description
+        self.bindings = bindings
+        self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
+        self.offer_name = offer_name
+        self.offer_url = offer_url
+        self.offer_uuid = offer_uuid
+        self.source_model_tag = source_model_tag
+        self.spaces = [RemoteSpace.from_json(o) for o in spaces or []]
+        self.users = [OfferUserDetails.from_json(o) for o in users or []]
+
+
+
+class ApplicationOfferResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : ApplicationOfferAdminDetails
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = ApplicationOfferAdminDetails.from_json(result) if result else None
+
+
+
+class ApplicationOfferStatus(Type):
+    _toSchema = {'active_connected_count': 'active-connected-count', 'application_name': 'application-name', 'charm': 'charm', 'endpoints': 'endpoints', 'err': 'err', 'offer_name': 'offer-name', 'total_connected_count': 'total-connected-count'}
+    _toPy = {'active-connected-count': 'active_connected_count', 'application-name': 'application_name', 'charm': 'charm', 'endpoints': 'endpoints', 'err': 'err', 'offer-name': 'offer_name', 'total-connected-count': 'total_connected_count'}
+    def __init__(self, active_connected_count=None, application_name=None, charm=None, endpoints=None, err=None, offer_name=None, total_connected_count=None, **unknown_fields):
+        '''
+        active_connected_count : int
+        application_name : str
+        charm : str
+        endpoints : typing.Mapping[str, ~RemoteEndpoint]
+        err : typing.Mapping[str, typing.Any]
+        offer_name : str
+        total_connected_count : int
+        '''
+        self.active_connected_count = active_connected_count
+        self.application_name = application_name
+        self.charm = charm
+        self.endpoints = endpoints
+        self.err = err
+        self.offer_name = offer_name
+        self.total_connected_count = total_connected_count
+
+
+
+class ApplicationOffersResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ApplicationOfferResult]
+        '''
+        self.results = [ApplicationOfferResult.from_json(o) for o in results or []]
+
+
+
 class ApplicationRelationsChange(Type):
     _toSchema = {'changed': 'changed', 'removed': 'removed'}
     _toPy = {'changed': 'changed', 'removed': 'removed'}
     def __init__(self, changed=None, removed=None, **unknown_fields):
         '''
-        changed : typing.Sequence<+T_co>[~RelationChange]<~RelationChange>
-        removed : typing.Sequence<+T_co>[int]
+        changed : typing.Sequence[~RelationChange]
+        removed : typing.Sequence[int]
         '''
         self.changed = [RelationChange.from_json(o) for o in changed or []]
         self.removed = removed
@@ -755,7 +1054,7 @@ class ApplicationSet(Type):
     def __init__(self, application=None, options=None, **unknown_fields):
         '''
         application : str
-        options : typing.Mapping<~KT, +VT_co>[str, str]
+        options : typing.Mapping[str, str]
         '''
         self.application = application
         self.options = options
@@ -770,12 +1069,12 @@ class ApplicationSetCharm(Type):
         application : str
         channel : str
         charm_url : str
-        config_settings : typing.Mapping<~KT, +VT_co>[str, str]
+        config_settings : typing.Mapping[str, str]
         config_settings_yaml : str
         force_series : bool
         force_units : bool
-        resource_ids : typing.Mapping<~KT, +VT_co>[str, str]
-        storage_constraints : typing.Mapping<~KT, +VT_co>[str, ~StorageConstraints]<~StorageConstraints>
+        resource_ids : typing.Mapping[str, str]
+        storage_constraints : typing.Mapping[str, ~StorageConstraints]
         '''
         self.application = application
         self.channel = channel
@@ -789,6 +1088,19 @@ class ApplicationSetCharm(Type):
 
 
 
+class ApplicationSetCharmProfile(Type):
+    _toSchema = {'application': 'application', 'charm_url': 'charm-url'}
+    _toPy = {'application': 'application', 'charm-url': 'charm_url'}
+    def __init__(self, application=None, charm_url=None, **unknown_fields):
+        '''
+        application : str
+        charm_url : str
+        '''
+        self.application = application
+        self.charm_url = charm_url
+
+
+
 class ApplicationStatus(Type):
     _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'}
     _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'}
@@ -796,15 +1108,15 @@ class ApplicationStatus(Type):
         '''
         can_upgrade_to : str
         charm : str
-        err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        err : typing.Mapping[str, typing.Any]
         exposed : bool
         life : str
-        meter_statuses : typing.Mapping<~KT, +VT_co>[str, ~MeterStatus]<~MeterStatus>
-        relations : typing.Sequence<+T_co>[str]
+        meter_statuses : typing.Mapping[str, ~MeterStatus]
+        relations : typing.Sequence[str]
         series : str
         status : DetailedStatus
-        subordinate_to : typing.Sequence<+T_co>[str]
-        units : typing.Mapping<~KT, +VT_co>[str, ~UnitStatus]<~UnitStatus>
+        subordinate_to : typing.Sequence[str]
+        units : typing.Mapping[str, ~UnitStatus]
         workload_version : str
         '''
         self.can_upgrade_to = can_upgrade_to
@@ -829,7 +1141,7 @@ class ApplicationStatusResult(Type):
         '''
         application : StatusResult
         error : Error
-        units : typing.Mapping<~KT, +VT_co>[str, ~StatusResult]<~StatusResult>
+        units : typing.Mapping[str, ~StatusResult]
         '''
         self.application = StatusResult.from_json(application) if application else None
         self.error = Error.from_json(error) if error else None
@@ -842,7 +1154,7 @@ class ApplicationStatusResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ApplicationStatusResult]<~ApplicationStatusResult>
+        results : typing.Sequence[~ApplicationStatusResult]
         '''
         self.results = [ApplicationStatusResult.from_json(o) for o in results or []]
 
@@ -864,7 +1176,7 @@ class ApplicationURLs(Type):
     _toPy = {'application-urls': 'application_urls'}
     def __init__(self, application_urls=None, **unknown_fields):
         '''
-        application_urls : typing.Sequence<+T_co>[str]
+        application_urls : typing.Sequence[str]
         '''
         self.application_urls = application_urls
 
@@ -881,13 +1193,38 @@ class ApplicationUnexpose(Type):
 
 
 
+class ApplicationUnitParams(Type):
+    _toSchema = {'address': 'address', 'data': 'data', 'filesystem_info': 'filesystem-info', 'info': 'info', 'ports': 'ports', 'provider_id': 'provider-id', 'status': 'status', 'unit_tag': 'unit-tag'}
+    _toPy = {'address': 'address', 'data': 'data', 'filesystem-info': 'filesystem_info', 'info': 'info', 'ports': 'ports', 'provider-id': 'provider_id', 'status': 'status', 'unit-tag': 'unit_tag'}
+    def __init__(self, address=None, data=None, filesystem_info=None, info=None, ports=None, provider_id=None, status=None, unit_tag=None, **unknown_fields):
+        '''
+        address : str
+        data : typing.Mapping[str, typing.Any]
+        filesystem_info : typing.Sequence[~KubernetesFilesystemInfo]
+        info : str
+        ports : typing.Sequence[str]
+        provider_id : str
+        status : str
+        unit_tag : str
+        '''
+        self.address = address
+        self.data = data
+        self.filesystem_info = [KubernetesFilesystemInfo.from_json(o) for o in filesystem_info or []]
+        self.info = info
+        self.ports = ports
+        self.provider_id = provider_id
+        self.status = status
+        self.unit_tag = unit_tag
+
+
+
 class ApplicationUnset(Type):
     _toSchema = {'application': 'application', 'options': 'options'}
     _toPy = {'application': 'application', 'options': 'options'}
     def __init__(self, application=None, options=None, **unknown_fields):
         '''
         application : str
-        options : typing.Sequence<+T_co>[str]
+        options : typing.Sequence[str]
         '''
         self.application = application
         self.options = options
@@ -905,7 +1242,7 @@ class ApplicationUpdate(Type):
         force_charm_url : bool
         force_series : bool
         min_units : int
-        settings : typing.Mapping<~KT, +VT_co>[str, str]
+        settings : typing.Mapping[str, str]
         settings_yaml : str
         '''
         self.application = application
@@ -924,7 +1261,7 @@ class ApplicationsCharmActionsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ApplicationCharmActionsResult]<~ApplicationCharmActionsResult>
+        results : typing.Sequence[~ApplicationCharmActionsResult]
         '''
         self.results = [ApplicationCharmActionsResult.from_json(o) for o in results or []]
 
@@ -935,7 +1272,7 @@ class ApplicationsDeploy(Type):
     _toPy = {'applications': 'applications'}
     def __init__(self, applications=None, **unknown_fields):
         '''
-        applications : typing.Sequence<+T_co>[~ApplicationDeploy]<~ApplicationDeploy>
+        applications : typing.Sequence[~ApplicationDeploy]
         '''
         self.applications = [ApplicationDeploy.from_json(o) for o in applications or []]
 
@@ -979,7 +1316,7 @@ class BackupsListResult(Type):
     _toPy = {'list': 'list_'}
     def __init__(self, list_=None, **unknown_fields):
         '''
-        list_ : typing.Sequence<+T_co>[~BackupsMetadataResult]<~BackupsMetadataResult>
+        list_ : typing.Sequence[~BackupsMetadataResult]
         '''
         self.list_ = [BackupsMetadataResult.from_json(o) for o in list_ or []]
 
@@ -1073,7 +1410,7 @@ class BlockDevice(Type):
     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):
         '''
         busaddress : str
-        devicelinks : typing.Sequence<+T_co>[str]
+        devicelinks : typing.Sequence[str]
         devicename : str
         filesystemtype : str
         hardwareid : str
@@ -1114,7 +1451,7 @@ class BlockDeviceResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~BlockDeviceResult]<~BlockDeviceResult>
+        results : typing.Sequence[~BlockDeviceResult]
         '''
         self.results = [BlockDeviceResult.from_json(o) for o in results or []]
 
@@ -1138,7 +1475,7 @@ class BlockResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~BlockResult]<~BlockResult>
+        results : typing.Sequence[~BlockResult]
         '''
         self.results = [BlockResult.from_json(o) for o in results or []]
 
@@ -1175,21 +1512,32 @@ class BoolResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
+        results : typing.Sequence[~BoolResult]
         '''
         self.results = [BoolResult.from_json(o) for o in results or []]
 
 
 
+class BulkImportStorageParams(Type):
+    _toSchema = {'storage': 'storage'}
+    _toPy = {'storage': 'storage'}
+    def __init__(self, storage=None, **unknown_fields):
+        '''
+        storage : typing.Sequence[~ImportStorageParams]
+        '''
+        self.storage = [ImportStorageParams.from_json(o) for o in storage or []]
+
+
+
 class BundleChange(Type):
     _toSchema = {'args': 'args', 'id_': 'id', 'method': 'method', 'requires': 'requires'}
     _toPy = {'args': 'args', 'id': 'id_', 'method': 'method', 'requires': 'requires'}
     def __init__(self, args=None, id_=None, method=None, requires=None, **unknown_fields):
         '''
-        args : typing.Sequence<+T_co>[typing.Any]
+        args : typing.Sequence[typing.Any]
         id_ : str
         method : str
-        requires : typing.Sequence<+T_co>[str]
+        requires : typing.Sequence[str]
         '''
         self.args = args
         self.id_ = id_
@@ -1214,8 +1562,8 @@ class BundleChangesResults(Type):
     _toPy = {'changes': 'changes', 'errors': 'errors'}
     def __init__(self, changes=None, errors=None, **unknown_fields):
         '''
-        changes : typing.Sequence<+T_co>[~BundleChange]<~BundleChange>
-        errors : typing.Sequence<+T_co>[str]
+        changes : typing.Sequence[~BundleChange]
+        errors : typing.Sequence[str]
         '''
         self.changes = [BundleChange.from_json(o) for o in changes or []]
         self.errors = errors
@@ -1227,19 +1575,43 @@ class BytesResult(Type):
     _toPy = {'result': 'result'}
     def __init__(self, result=None, **unknown_fields):
         '''
-        result : typing.Sequence<+T_co>[int]
+        result : typing.Sequence[int]
         '''
         self.result = result
 
 
 
+class ChangeModelCredentialParams(Type):
+    _toSchema = {'credential_tag': 'credential-tag', 'model_tag': 'model-tag'}
+    _toPy = {'credential-tag': 'credential_tag', 'model-tag': 'model_tag'}
+    def __init__(self, credential_tag=None, model_tag=None, **unknown_fields):
+        '''
+        credential_tag : str
+        model_tag : str
+        '''
+        self.credential_tag = credential_tag
+        self.model_tag = model_tag
+
+
+
+class ChangeModelCredentialsParams(Type):
+    _toSchema = {'model_credentials': 'model-credentials'}
+    _toPy = {'model-credentials': 'model_credentials'}
+    def __init__(self, model_credentials=None, **unknown_fields):
+        '''
+        model_credentials : typing.Sequence[~ChangeModelCredentialParams]
+        '''
+        self.model_credentials = [ChangeModelCredentialParams.from_json(o) for o in model_credentials or []]
+
+
+
 class CharmActionSpec(Type):
     _toSchema = {'description': 'description', 'params': 'params'}
     _toPy = {'description': 'description', 'params': 'params'}
     def __init__(self, description=None, params=None, **unknown_fields):
         '''
         description : str
-        params : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        params : typing.Mapping[str, typing.Any]
         '''
         self.description = description
         self.params = params
@@ -1251,19 +1623,38 @@ class CharmActions(Type):
     _toPy = {'specs': 'specs'}
     def __init__(self, specs=None, **unknown_fields):
         '''
-        specs : typing.Mapping<~KT, +VT_co>[str, ~CharmActionSpec]<~CharmActionSpec>
+        specs : typing.Mapping[str, ~CharmActionSpec]
         '''
         self.specs = specs
 
 
 
+class CharmDevice(Type):
+    _toSchema = {'countmax': 'CountMax', 'countmin': 'CountMin', 'description': 'Description', 'name': 'Name', 'type_': 'Type'}
+    _toPy = {'CountMax': 'countmax', 'CountMin': 'countmin', 'Description': 'description', 'Name': 'name', 'Type': 'type_'}
+    def __init__(self, countmax=None, countmin=None, description=None, name=None, type_=None, **unknown_fields):
+        '''
+        countmax : int
+        countmin : int
+        description : str
+        name : str
+        type_ : str
+        '''
+        self.countmax = countmax
+        self.countmin = countmin
+        self.description = description
+        self.name = name
+        self.type_ = type_
+
+
+
 class CharmInfo(Type):
     _toSchema = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
     _toPy = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
     def __init__(self, actions=None, config=None, meta=None, metrics=None, revision=None, url=None, **unknown_fields):
         '''
         actions : CharmActions
-        config : typing.Mapping<~KT, +VT_co>[str, ~CharmOption]<~CharmOption>
+        config : typing.Mapping[str, ~CharmOption]
         meta : CharmMeta
         metrics : CharmMetrics
         revision : int
@@ -1278,27 +1669,42 @@ class CharmInfo(Type):
 
 
 
+class CharmLXDProfile(Type):
+    _toSchema = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+    _toPy = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+    def __init__(self, config=None, description=None, devices=None, **unknown_fields):
+        '''
+        config : typing.Mapping[str, str]
+        description : str
+        devices : typing.Mapping[str, typing.Any]
+        '''
+        self.config = config
+        self.description = description
+        self.devices = devices
+
+
+
 class CharmMeta(Type):
     _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'}
     _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'}
     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):
         '''
-        categories : typing.Sequence<+T_co>[str]
+        categories : typing.Sequence[str]
         description : str
-        extra_bindings : typing.Mapping<~KT, +VT_co>[str, str]
+        extra_bindings : typing.Mapping[str, str]
         min_juju_version : str
         name : str
-        payload_classes : typing.Mapping<~KT, +VT_co>[str, ~CharmPayloadClass]<~CharmPayloadClass>
-        peers : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
-        provides : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
-        requires : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
-        resources : typing.Mapping<~KT, +VT_co>[str, ~CharmResourceMeta]<~CharmResourceMeta>
-        series : typing.Sequence<+T_co>[str]
-        storage : typing.Mapping<~KT, +VT_co>[str, ~CharmStorage]<~CharmStorage>
+        payload_classes : typing.Mapping[str, ~CharmPayloadClass]
+        peers : typing.Mapping[str, ~CharmRelation]
+        provides : typing.Mapping[str, ~CharmRelation]
+        requires : typing.Mapping[str, ~CharmRelation]
+        resources : typing.Mapping[str, ~CharmResourceMeta]
+        series : typing.Sequence[str]
+        storage : typing.Mapping[str, ~CharmStorage]
         subordinate : bool
         summary : str
-        tags : typing.Sequence<+T_co>[str]
-        terms : typing.Sequence<+T_co>[str]
+        tags : typing.Sequence[str]
+        terms : typing.Sequence[str]
         '''
         self.categories = categories
         self.description = description
@@ -1337,7 +1743,7 @@ class CharmMetrics(Type):
     _toPy = {'metrics': 'metrics', 'plan': 'plan'}
     def __init__(self, metrics=None, plan=None, **unknown_fields):
         '''
-        metrics : typing.Mapping<~KT, +VT_co>[str, ~CharmMetric]<~CharmMetric>
+        metrics : typing.Mapping[str, ~CharmMetric]
         plan : CharmPlan
         '''
         self.metrics = metrics
@@ -1350,7 +1756,7 @@ class CharmOption(Type):
     _toPy = {'default': 'default', 'description': 'description', 'type': 'type_'}
     def __init__(self, default=None, description=None, type_=None, **unknown_fields):
         '''
-        default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        default : typing.Mapping[str, typing.Any]
         description : str
         type_ : str
         '''
@@ -1411,7 +1817,7 @@ class CharmResource(Type):
     def __init__(self, description=None, fingerprint=None, name=None, origin=None, path=None, revision=None, size=None, type_=None, **unknown_fields):
         '''
         description : str
-        fingerprint : typing.Sequence<+T_co>[int]
+        fingerprint : typing.Sequence[int]
         name : str
         origin : str
         path : str
@@ -1458,7 +1864,7 @@ class CharmStorage(Type):
         location : str
         minimum_size : int
         name : str
-        properties : typing.Sequence<+T_co>[str]
+        properties : typing.Sequence[str]
         read_only : bool
         shared : bool
         type_ : str
@@ -1492,7 +1898,7 @@ class CharmURLs(Type):
     _toPy = {'urls': 'urls'}
     def __init__(self, urls=None, **unknown_fields):
         '''
-        urls : typing.Sequence<+T_co>[~CharmURL]<~CharmURL>
+        urls : typing.Sequence[~CharmURL]
         '''
         self.urls = [CharmURL.from_json(o) for o in urls or []]
 
@@ -1503,7 +1909,7 @@ class CharmsList(Type):
     _toPy = {'names': 'names'}
     def __init__(self, names=None, **unknown_fields):
         '''
-        names : typing.Sequence<+T_co>[str]
+        names : typing.Sequence[str]
         '''
         self.names = names
 
@@ -1514,7 +1920,7 @@ class CharmsListResult(Type):
     _toPy = {'charm-urls': 'charm_urls'}
     def __init__(self, charm_urls=None, **unknown_fields):
         '''
-        charm_urls : typing.Sequence<+T_co>[str]
+        charm_urls : typing.Sequence[str]
         '''
         self.charm_urls = charm_urls
 
@@ -1525,7 +1931,7 @@ class ClaimLeadershipBulkParams(Type):
     _toPy = {'params': 'params'}
     def __init__(self, params=None, **unknown_fields):
         '''
-        params : typing.Sequence<+T_co>[~ClaimLeadershipParams]<~ClaimLeadershipParams>
+        params : typing.Sequence[~ClaimLeadershipParams]
         '''
         self.params = [ClaimLeadershipParams.from_json(o) for o in params or []]
 
@@ -1536,7 +1942,7 @@ class ClaimLeadershipBulkResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+        results : typing.Sequence[~ErrorResult]
         '''
         self.results = [ErrorResult.from_json(o) for o in results or []]
 
@@ -1562,10 +1968,10 @@ class Cloud(Type):
     _toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
     def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None, **unknown_fields):
         '''
-        auth_types : typing.Sequence<+T_co>[str]
+        auth_types : typing.Sequence[str]
         endpoint : str
         identity_endpoint : str
-        regions : typing.Sequence<+T_co>[~CloudRegion]<~CloudRegion>
+        regions : typing.Sequence[~CloudRegion]
         storage_endpoint : str
         type_ : str
         '''
@@ -1583,9 +1989,9 @@ class CloudCredential(Type):
     _toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'redacted': 'redacted'}
     def __init__(self, attrs=None, auth_type=None, redacted=None, **unknown_fields):
         '''
-        attrs : typing.Mapping<~KT, +VT_co>[str, str]
+        attrs : typing.Mapping[str, str]
         auth_type : str
-        redacted : typing.Sequence<+T_co>[str]
+        redacted : typing.Sequence[str]
         '''
         self.attrs = attrs
         self.auth_type = auth_type
@@ -1593,9 +1999,35 @@ class CloudCredential(Type):
 
 
 
-class CloudCredentialResult(Type):
-    _toSchema = {'error': 'error', 'result': 'result'}
-    _toPy = {'error': 'error', 'result': 'result'}
+class CloudCredentialArg(Type):
+    _toSchema = {'cloud_name': 'cloud-name', 'credential_name': 'credential-name'}
+    _toPy = {'cloud-name': 'cloud_name', 'credential-name': 'credential_name'}
+    def __init__(self, cloud_name=None, credential_name=None, **unknown_fields):
+        '''
+        cloud_name : str
+        credential_name : str
+        '''
+        self.cloud_name = cloud_name
+        self.credential_name = credential_name
+
+
+
+class CloudCredentialArgs(Type):
+    _toSchema = {'credentials': 'credentials', 'include_secrets': 'include-secrets'}
+    _toPy = {'credentials': 'credentials', 'include-secrets': 'include_secrets'}
+    def __init__(self, credentials=None, include_secrets=None, **unknown_fields):
+        '''
+        credentials : typing.Sequence[~CloudCredentialArg]
+        include_secrets : bool
+        '''
+        self.credentials = [CloudCredentialArg.from_json(o) for o in credentials or []]
+        self.include_secrets = include_secrets
+
+
+
+class CloudCredentialResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
     def __init__(self, error=None, result=None, **unknown_fields):
         '''
         error : Error
@@ -1611,12 +2043,33 @@ class CloudCredentialResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~CloudCredentialResult]<~CloudCredentialResult>
+        results : typing.Sequence[~CloudCredentialResult]
         '''
         self.results = [CloudCredentialResult.from_json(o) for o in results or []]
 
 
 
+class CloudDetails(Type):
+    _toSchema = {'auth_types': 'auth-types', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'regions': 'regions', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
+    _toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
+    def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None, **unknown_fields):
+        '''
+        auth_types : typing.Sequence[str]
+        endpoint : str
+        identity_endpoint : str
+        regions : typing.Sequence[~CloudRegion]
+        storage_endpoint : str
+        type_ : str
+        '''
+        self.auth_types = auth_types
+        self.endpoint = endpoint
+        self.identity_endpoint = identity_endpoint
+        self.regions = [CloudRegion.from_json(o) for o in regions or []]
+        self.storage_endpoint = storage_endpoint
+        self.type_ = type_
+
+
+
 class CloudImageMetadata(Type):
     _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'}
     _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'}
@@ -1653,12 +2106,49 @@ class CloudImageMetadataList(Type):
     _toPy = {'metadata': 'metadata'}
     def __init__(self, metadata=None, **unknown_fields):
         '''
-        metadata : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
+        metadata : typing.Sequence[~CloudImageMetadata]
         '''
         self.metadata = [CloudImageMetadata.from_json(o) for o in metadata or []]
 
 
 
+class CloudInfo(Type):
+    _toSchema = {'clouddetails': 'CloudDetails', 'users': 'users'}
+    _toPy = {'CloudDetails': 'clouddetails', 'users': 'users'}
+    def __init__(self, clouddetails=None, users=None, **unknown_fields):
+        '''
+        clouddetails : CloudDetails
+        users : typing.Sequence[~CloudUserInfo]
+        '''
+        self.clouddetails = CloudDetails.from_json(clouddetails) if clouddetails else None
+        self.users = [CloudUserInfo.from_json(o) for o in users or []]
+
+
+
+class CloudInfoResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : CloudInfo
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = CloudInfo.from_json(result) if result else None
+
+
+
+class CloudInfoResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~CloudInfoResult]
+        '''
+        self.results = [CloudInfoResult.from_json(o) for o in results or []]
+
+
+
 class CloudInstanceTypesConstraint(Type):
     _toSchema = {'cloud_tag': 'cloud-tag', 'constraints': 'constraints', 'region': 'region'}
     _toPy = {'cloud-tag': 'cloud_tag', 'constraints': 'constraints', 'region': 'region'}
@@ -1679,7 +2169,7 @@ class CloudInstanceTypesConstraints(Type):
     _toPy = {'constraints': 'constraints'}
     def __init__(self, constraints=None, **unknown_fields):
         '''
-        constraints : typing.Sequence<+T_co>[~CloudInstanceTypesConstraint]<~CloudInstanceTypesConstraint>
+        constraints : typing.Sequence[~CloudInstanceTypesConstraint]
         '''
         self.constraints = [CloudInstanceTypesConstraint.from_json(o) for o in constraints or []]
 
@@ -1720,7 +2210,7 @@ class CloudResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~CloudResult]<~CloudResult>
+        results : typing.Sequence[~CloudResult]
         '''
         self.results = [CloudResult.from_json(o) for o in results or []]
 
@@ -1767,30 +2257,58 @@ class CloudSpecResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
+        results : typing.Sequence[~CloudSpecResult]
         '''
         self.results = [CloudSpecResult.from_json(o) for o in results or []]
 
 
 
+class CloudUserInfo(Type):
+    _toSchema = {'access': 'access', 'display_name': 'display-name', 'user': 'user'}
+    _toPy = {'access': 'access', 'display-name': 'display_name', 'user': 'user'}
+    def __init__(self, access=None, display_name=None, user=None, **unknown_fields):
+        '''
+        access : str
+        display_name : str
+        user : str
+        '''
+        self.access = access
+        self.display_name = display_name
+        self.user = user
+
+
+
 class CloudsResult(Type):
     _toSchema = {'clouds': 'clouds'}
     _toPy = {'clouds': 'clouds'}
     def __init__(self, clouds=None, **unknown_fields):
         '''
-        clouds : typing.Mapping<~KT, +VT_co>[str, ~Cloud]<~Cloud>
+        clouds : typing.Mapping[str, ~Cloud]
         '''
         self.clouds = clouds
 
 
 
+class ConfigResult(Type):
+    _toSchema = {'config': 'config', 'error': 'error'}
+    _toPy = {'config': 'config', 'error': 'error'}
+    def __init__(self, config=None, error=None, **unknown_fields):
+        '''
+        config : typing.Mapping[str, typing.Any]
+        error : Error
+        '''
+        self.config = config
+        self.error = Error.from_json(error) if error else None
+
+
+
 class ConfigSettingsResult(Type):
     _toSchema = {'error': 'error', 'settings': 'settings'}
     _toPy = {'error': 'error', 'settings': 'settings'}
     def __init__(self, error=None, settings=None, **unknown_fields):
         '''
         error : Error
-        settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        settings : typing.Mapping[str, typing.Any]
         '''
         self.error = Error.from_json(error) if error else None
         self.settings = settings
@@ -1802,7 +2320,7 @@ class ConfigSettingsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ConfigSettingsResult]<~ConfigSettingsResult>
+        results : typing.Sequence[~ConfigSettingsResult]
         '''
         self.results = [ConfigSettingsResult.from_json(o) for o in results or []]
 
@@ -1814,7 +2332,7 @@ class ConfigValue(Type):
     def __init__(self, source=None, value=None, **unknown_fields):
         '''
         source : str
-        value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        value : typing.Mapping[str, typing.Any]
         '''
         self.source = source
         self.value = value
@@ -1854,7 +2372,7 @@ class ConstraintsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ConstraintsResult]<~ConstraintsResult>
+        results : typing.Sequence[~ConstraintsResult]
         '''
         self.results = [ConstraintsResult.from_json(o) for o in results or []]
 
@@ -1878,7 +2396,7 @@ class ConsumeApplicationArgs(Type):
     _toPy = {'args': 'args'}
     def __init__(self, args=None, **unknown_fields):
         '''
-        args : typing.Sequence<+T_co>[~ConsumeApplicationArg]<~ConsumeApplicationArg>
+        args : typing.Sequence[~ConsumeApplicationArg]
         '''
         self.args = [ConsumeApplicationArg.from_json(o) for o in args or []]
 
@@ -1902,12 +2420,51 @@ class ConsumeApplicationResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ConsumeApplicationResult]<~ConsumeApplicationResult>
+        results : typing.Sequence[~ConsumeApplicationResult]
         '''
         self.results = [ConsumeApplicationResult.from_json(o) for o in results or []]
 
 
 
+class ConsumeOfferDetails(Type):
+    _toSchema = {'external_controller': 'external-controller', 'macaroon': 'macaroon', 'offer': 'offer'}
+    _toPy = {'external-controller': 'external_controller', 'macaroon': 'macaroon', 'offer': 'offer'}
+    def __init__(self, external_controller=None, macaroon=None, offer=None, **unknown_fields):
+        '''
+        external_controller : ExternalControllerInfo
+        macaroon : Macaroon
+        offer : ApplicationOfferDetails
+        '''
+        self.external_controller = ExternalControllerInfo.from_json(external_controller) if external_controller else None
+        self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+        self.offer = ApplicationOfferDetails.from_json(offer) if offer else None
+
+
+
+class ConsumeOfferDetailsResult(Type):
+    _toSchema = {'consumeofferdetails': 'ConsumeOfferDetails', 'error': 'error'}
+    _toPy = {'ConsumeOfferDetails': 'consumeofferdetails', 'error': 'error'}
+    def __init__(self, consumeofferdetails=None, error=None, **unknown_fields):
+        '''
+        consumeofferdetails : ConsumeOfferDetails
+        error : Error
+        '''
+        self.consumeofferdetails = ConsumeOfferDetails.from_json(consumeofferdetails) if consumeofferdetails else None
+        self.error = Error.from_json(error) if error else None
+
+
+
+class ConsumeOfferDetailsResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ConsumeOfferDetailsResult]
+        '''
+        self.results = [ConsumeOfferDetailsResult.from_json(o) for o in results or []]
+
+
+
 class ContainerConfig(Type):
     _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'}
     _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'}
@@ -1931,12 +2488,25 @@ class ContainerConfig(Type):
 
 
 
+class ContainerLXDProfile(Type):
+    _toSchema = {'name': 'name', 'profile': 'profile'}
+    _toPy = {'name': 'name', 'profile': 'profile'}
+    def __init__(self, name=None, profile=None, **unknown_fields):
+        '''
+        name : str
+        profile : CharmLXDProfile
+        '''
+        self.name = name
+        self.profile = CharmLXDProfile.from_json(profile) if profile else None
+
+
+
 class ContainerManagerConfig(Type):
     _toSchema = {'config': 'config'}
     _toPy = {'config': 'config'}
     def __init__(self, config=None, **unknown_fields):
         '''
-        config : typing.Mapping<~KT, +VT_co>[str, str]
+        config : typing.Mapping[str, str]
         '''
         self.config = config
 
@@ -1953,17 +2523,91 @@ class ContainerManagerConfigParams(Type):
 
 
 
+class ContainerProfileResult(Type):
+    _toSchema = {'error': 'error', 'lxd_profiles': 'lxd-profiles'}
+    _toPy = {'error': 'error', 'lxd-profiles': 'lxd_profiles'}
+    def __init__(self, error=None, lxd_profiles=None, **unknown_fields):
+        '''
+        error : Error
+        lxd_profiles : typing.Sequence[~ContainerLXDProfile]
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.lxd_profiles = [ContainerLXDProfile.from_json(o) for o in lxd_profiles or []]
+
+
+
+class ContainerProfileResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ContainerProfileResult]
+        '''
+        self.results = [ContainerProfileResult.from_json(o) for o in results or []]
+
+
+
+class ControllerAPIInfoResult(Type):
+    _toSchema = {'addresses': 'addresses', 'cacert': 'cacert', 'error': 'error'}
+    _toPy = {'addresses': 'addresses', 'cacert': 'cacert', 'error': 'error'}
+    def __init__(self, addresses=None, cacert=None, error=None, **unknown_fields):
+        '''
+        addresses : typing.Sequence[str]
+        cacert : str
+        error : Error
+        '''
+        self.addresses = addresses
+        self.cacert = cacert
+        self.error = Error.from_json(error) if error else None
+
+
+
+class ControllerAPIInfoResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ControllerAPIInfoResult]
+        '''
+        self.results = [ControllerAPIInfoResult.from_json(o) for o in results or []]
+
+
+
 class ControllerConfigResult(Type):
     _toSchema = {'config': 'config'}
     _toPy = {'config': 'config'}
     def __init__(self, config=None, **unknown_fields):
         '''
-        config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        config : typing.Mapping[str, typing.Any]
+        '''
+        self.config = config
+
+
+
+class ControllerConfigSet(Type):
+    _toSchema = {'config': 'config'}
+    _toPy = {'config': 'config'}
+    def __init__(self, config=None, **unknown_fields):
+        '''
+        config : typing.Mapping[str, typing.Any]
         '''
         self.config = config
 
 
 
+class ControllerCredentialInfo(Type):
+    _toSchema = {'content': 'content', 'models': 'models'}
+    _toPy = {'content': 'content', 'models': 'models'}
+    def __init__(self, content=None, models=None, **unknown_fields):
+        '''
+        content : CredentialContent
+        models : typing.Sequence[~ModelAccess]
+        '''
+        self.content = CredentialContent.from_json(content) if content else None
+        self.models = [ModelAccess.from_json(o) for o in models or []]
+
+
+
 class ControllersChangeResult(Type):
     _toSchema = {'error': 'error', 'result': 'result'}
     _toPy = {'error': 'error', 'result': 'result'}
@@ -1982,7 +2626,7 @@ class ControllersChangeResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ControllersChangeResult]<~ControllersChangeResult>
+        results : typing.Sequence[~ControllersChangeResult]
         '''
         self.results = [ControllersChangeResult.from_json(o) for o in results or []]
 
@@ -1993,12 +2637,12 @@ class ControllersChanges(Type):
     _toPy = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
     def __init__(self, added=None, converted=None, demoted=None, maintained=None, promoted=None, removed=None, **unknown_fields):
         '''
-        added : typing.Sequence<+T_co>[str]
-        converted : typing.Sequence<+T_co>[str]
-        demoted : typing.Sequence<+T_co>[str]
-        maintained : typing.Sequence<+T_co>[str]
-        promoted : typing.Sequence<+T_co>[str]
-        removed : typing.Sequence<+T_co>[str]
+        added : typing.Sequence[str]
+        converted : typing.Sequence[str]
+        demoted : typing.Sequence[str]
+        maintained : typing.Sequence[str]
+        promoted : typing.Sequence[str]
+        removed : typing.Sequence[str]
         '''
         self.added = added
         self.converted = converted
@@ -2016,7 +2660,7 @@ class ControllersSpec(Type):
         '''
         constraints : Value
         num_controllers : int
-        placement : typing.Sequence<+T_co>[str]
+        placement : typing.Sequence[str]
         series : str
         '''
         self.constraints = Value.from_json(constraints) if constraints else None
@@ -2031,7 +2675,7 @@ class ControllersSpecs(Type):
     _toPy = {'specs': 'specs'}
     def __init__(self, specs=None, **unknown_fields):
         '''
-        specs : typing.Sequence<+T_co>[~ControllersSpec]<~ControllersSpec>
+        specs : typing.Sequence[~ControllersSpec]
         '''
         self.specs = [ControllersSpec.from_json(o) for o in specs or []]
 
@@ -2045,7 +2689,7 @@ class CreateSpaceParams(Type):
         provider_id : str
         public : bool
         space_tag : str
-        subnet_tags : typing.Sequence<+T_co>[str]
+        subnet_tags : typing.Sequence[str]
         '''
         self.provider_id = provider_id
         self.public = public
@@ -2059,18 +2703,59 @@ class CreateSpacesParams(Type):
     _toPy = {'spaces': 'spaces'}
     def __init__(self, spaces=None, **unknown_fields):
         '''
-        spaces : typing.Sequence<+T_co>[~CreateSpaceParams]<~CreateSpaceParams>
+        spaces : typing.Sequence[~CreateSpaceParams]
         '''
         self.spaces = [CreateSpaceParams.from_json(o) for o in spaces or []]
 
 
 
+class CredentialContent(Type):
+    _toSchema = {'attrs': 'attrs', 'auth_type': 'auth-type', 'cloud': 'cloud', 'name': 'name'}
+    _toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'cloud': 'cloud', 'name': 'name'}
+    def __init__(self, attrs=None, auth_type=None, cloud=None, name=None, **unknown_fields):
+        '''
+        attrs : typing.Mapping[str, str]
+        auth_type : str
+        cloud : str
+        name : str
+        '''
+        self.attrs = attrs
+        self.auth_type = auth_type
+        self.cloud = cloud
+        self.name = name
+
+
+
+class CredentialContentResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : ControllerCredentialInfo
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = ControllerCredentialInfo.from_json(result) if result else None
+
+
+
+class CredentialContentResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~CredentialContentResult]
+        '''
+        self.results = [CredentialContentResult.from_json(o) for o in results or []]
+
+
+
 class Delta(Type):
     _toSchema = {'entity': 'entity', 'removed': 'removed'}
     _toPy = {'entity': 'entity', 'removed': 'removed'}
     def __init__(self, entity=None, removed=None, **unknown_fields):
         '''
-        entity : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        entity : typing.Mapping[str, typing.Any]
         removed : bool
         '''
         self.entity = entity
@@ -2083,8 +2768,8 @@ class DeployerConnectionValues(Type):
     _toPy = {'api-addresses': 'api_addresses', 'state-addresses': 'state_addresses'}
     def __init__(self, api_addresses=None, state_addresses=None, **unknown_fields):
         '''
-        api_addresses : typing.Sequence<+T_co>[str]
-        state_addresses : typing.Sequence<+T_co>[str]
+        api_addresses : typing.Sequence[str]
+        state_addresses : typing.Sequence[str]
         '''
         self.api_addresses = api_addresses
         self.state_addresses = state_addresses
@@ -2096,9 +2781,9 @@ class DestroyApplicationInfo(Type):
     _toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
     def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None, **unknown_fields):
         '''
-        destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
-        destroyed_units : typing.Sequence<+T_co>[~Entity]<~Entity>
-        detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
+        destroyed_storage : typing.Sequence[~Entity]
+        destroyed_units : typing.Sequence[~Entity]
+        detached_storage : typing.Sequence[~Entity]
         '''
         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
         self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
@@ -2106,6 +2791,32 @@ class DestroyApplicationInfo(Type):
 
 
 
+class DestroyApplicationOffers(Type):
+    _toSchema = {'force': 'force', 'offer_urls': 'offer-urls'}
+    _toPy = {'force': 'force', 'offer-urls': 'offer_urls'}
+    def __init__(self, force=None, offer_urls=None, **unknown_fields):
+        '''
+        force : bool
+        offer_urls : typing.Sequence[str]
+        '''
+        self.force = force
+        self.offer_urls = offer_urls
+
+
+
+class DestroyApplicationParams(Type):
+    _toSchema = {'application_tag': 'application-tag', 'destroy_storage': 'destroy-storage'}
+    _toPy = {'application-tag': 'application_tag', 'destroy-storage': 'destroy_storage'}
+    def __init__(self, application_tag=None, destroy_storage=None, **unknown_fields):
+        '''
+        application_tag : str
+        destroy_storage : bool
+        '''
+        self.application_tag = application_tag
+        self.destroy_storage = destroy_storage
+
+
+
 class DestroyApplicationResult(Type):
     _toSchema = {'error': 'error', 'info': 'info'}
     _toPy = {'error': 'error', 'info': 'info'}
@@ -2124,7 +2835,7 @@ class DestroyApplicationResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~DestroyApplicationResult]<~DestroyApplicationResult>
+        results : typing.Sequence[~DestroyApplicationResult]
         '''
         self.results = [DestroyApplicationResult.from_json(o) for o in results or []]
 
@@ -2135,12 +2846,45 @@ class DestroyApplicationUnits(Type):
     _toPy = {'unit-names': 'unit_names'}
     def __init__(self, unit_names=None, **unknown_fields):
         '''
-        unit_names : typing.Sequence<+T_co>[str]
+        unit_names : typing.Sequence[str]
         '''
         self.unit_names = unit_names
 
 
 
+class DestroyApplicationsParams(Type):
+    _toSchema = {'applications': 'applications'}
+    _toPy = {'applications': 'applications'}
+    def __init__(self, applications=None, **unknown_fields):
+        '''
+        applications : typing.Sequence[~DestroyApplicationParams]
+        '''
+        self.applications = [DestroyApplicationParams.from_json(o) for o in applications or []]
+
+
+
+class DestroyConsumedApplicationParams(Type):
+    _toSchema = {'application_tag': 'application-tag'}
+    _toPy = {'application-tag': 'application_tag'}
+    def __init__(self, application_tag=None, **unknown_fields):
+        '''
+        application_tag : str
+        '''
+        self.application_tag = application_tag
+
+
+
+class DestroyConsumedApplicationsParams(Type):
+    _toSchema = {'applications': 'applications'}
+    _toPy = {'applications': 'applications'}
+    def __init__(self, applications=None, **unknown_fields):
+        '''
+        applications : typing.Sequence[~DestroyConsumedApplicationParams]
+        '''
+        self.applications = [DestroyConsumedApplicationParams.from_json(o) for o in applications or []]
+
+
+
 class DestroyControllerArgs(Type):
     _toSchema = {'destroy_models': 'destroy-models'}
     _toPy = {'destroy-models': 'destroy_models'}
@@ -2157,9 +2901,9 @@ class DestroyMachineInfo(Type):
     _toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
     def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None, **unknown_fields):
         '''
-        destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
-        destroyed_units : typing.Sequence<+T_co>[~Entity]<~Entity>
-        detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
+        destroyed_storage : typing.Sequence[~Entity]
+        destroyed_units : typing.Sequence[~Entity]
+        detached_storage : typing.Sequence[~Entity]
         '''
         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
         self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
@@ -2185,7 +2929,7 @@ class DestroyMachineResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~DestroyMachineResult]<~DestroyMachineResult>
+        results : typing.Sequence[~DestroyMachineResult]
         '''
         self.results = [DestroyMachineResult.from_json(o) for o in results or []]
 
@@ -2197,19 +2941,58 @@ class DestroyMachines(Type):
     def __init__(self, force=None, machine_names=None, **unknown_fields):
         '''
         force : bool
-        machine_names : typing.Sequence<+T_co>[str]
+        machine_names : typing.Sequence[str]
         '''
         self.force = force
         self.machine_names = machine_names
 
 
 
+class DestroyMachinesParams(Type):
+    _toSchema = {'force': 'force', 'keep': 'keep', 'machine_tags': 'machine-tags'}
+    _toPy = {'force': 'force', 'keep': 'keep', 'machine-tags': 'machine_tags'}
+    def __init__(self, force=None, keep=None, machine_tags=None, **unknown_fields):
+        '''
+        force : bool
+        keep : bool
+        machine_tags : typing.Sequence[str]
+        '''
+        self.force = force
+        self.keep = keep
+        self.machine_tags = machine_tags
+
+
+
+class DestroyModelParams(Type):
+    _toSchema = {'destroy_storage': 'destroy-storage', 'model_tag': 'model-tag'}
+    _toPy = {'destroy-storage': 'destroy_storage', 'model-tag': 'model_tag'}
+    def __init__(self, destroy_storage=None, model_tag=None, **unknown_fields):
+        '''
+        destroy_storage : bool
+        model_tag : str
+        '''
+        self.destroy_storage = destroy_storage
+        self.model_tag = model_tag
+
+
+
+class DestroyModelsParams(Type):
+    _toSchema = {'models': 'models'}
+    _toPy = {'models': 'models'}
+    def __init__(self, models=None, **unknown_fields):
+        '''
+        models : typing.Sequence[~DestroyModelParams]
+        '''
+        self.models = [DestroyModelParams.from_json(o) for o in models or []]
+
+
+
 class DestroyRelation(Type):
     _toSchema = {'endpoints': 'endpoints'}
     _toPy = {'endpoints': 'endpoints'}
     def __init__(self, endpoints=None, **unknown_fields):
         '''
-        endpoints : typing.Sequence<+T_co>[str]
+        endpoints : typing.Sequence[str]
         '''
         self.endpoints = endpoints
 
@@ -2220,14 +3003,27 @@ class DestroyUnitInfo(Type):
     _toPy = {'destroyed-storage': 'destroyed_storage', 'detached-storage': 'detached_storage'}
     def __init__(self, destroyed_storage=None, detached_storage=None, **unknown_fields):
         '''
-        destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
-        detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
+        destroyed_storage : typing.Sequence[~Entity]
+        detached_storage : typing.Sequence[~Entity]
         '''
         self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
         self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
 
 
 
+class DestroyUnitParams(Type):
+    _toSchema = {'destroy_storage': 'destroy-storage', 'unit_tag': 'unit-tag'}
+    _toPy = {'destroy-storage': 'destroy_storage', 'unit-tag': 'unit_tag'}
+    def __init__(self, destroy_storage=None, unit_tag=None, **unknown_fields):
+        '''
+        destroy_storage : bool
+        unit_tag : str
+        '''
+        self.destroy_storage = destroy_storage
+        self.unit_tag = unit_tag
+
+
+
 class DestroyUnitResult(Type):
     _toSchema = {'error': 'error', 'info': 'info'}
     _toPy = {'error': 'error', 'info': 'info'}
@@ -2246,19 +3042,30 @@ class DestroyUnitResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~DestroyUnitResult]<~DestroyUnitResult>
+        results : typing.Sequence[~DestroyUnitResult]
         '''
         self.results = [DestroyUnitResult.from_json(o) for o in results or []]
 
 
 
+class DestroyUnitsParams(Type):
+    _toSchema = {'units': 'units'}
+    _toPy = {'units': 'units'}
+    def __init__(self, units=None, **unknown_fields):
+        '''
+        units : typing.Sequence[~DestroyUnitParams]
+        '''
+        self.units = [DestroyUnitParams.from_json(o) for o in units or []]
+
+
+
 class DetailedStatus(Type):
     _toSchema = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
     _toPy = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
     def __init__(self, data=None, err=None, info=None, kind=None, life=None, since=None, status=None, version=None, **unknown_fields):
         '''
-        data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
-        err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        data : typing.Mapping[str, typing.Any]
+        err : typing.Mapping[str, typing.Any]
         info : str
         kind : str
         life : str
@@ -2295,7 +3102,7 @@ class DiscoverSpacesResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ProviderSpace]<~ProviderSpace>
+        results : typing.Sequence[~ProviderSpace]
         '''
         self.results = [ProviderSpace.from_json(o) for o in results or []]
 
@@ -2307,7 +3114,7 @@ class DistributionGroupResult(Type):
     def __init__(self, error=None, result=None, **unknown_fields):
         '''
         error : Error
-        result : typing.Sequence<+T_co>[str]
+        result : typing.Sequence[str]
         '''
         self.error = Error.from_json(error) if error else None
         self.result = result
@@ -2319,7 +3126,7 @@ class DistributionGroupResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~DistributionGroupResult]<~DistributionGroupResult>
+        results : typing.Sequence[~DistributionGroupResult]
         '''
         self.results = [DistributionGroupResult.from_json(o) for o in results or []]
 
@@ -2330,7 +3137,7 @@ class DumpModelRequest(Type):
     _toPy = {'entities': 'entities', 'simplified': 'simplified'}
     def __init__(self, entities=None, simplified=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+        entities : typing.Sequence[~Entity]
         simplified : bool
         '''
         self.entities = [Entity.from_json(o) for o in entities or []]
@@ -2351,15 +3158,30 @@ class Endpoint(Type):
 
 
 
-class EndpointStatus(Type):
-    _toSchema = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
-    _toPy = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
-    def __init__(self, application=None, name=None, role=None, subordinate=None, **unknown_fields):
+class EndpointFilterAttributes(Type):
+    _toSchema = {'interface': 'interface', 'name': 'name', 'role': 'role'}
+    _toPy = {'interface': 'interface', 'name': 'name', 'role': 'role'}
+    def __init__(self, interface=None, name=None, role=None, **unknown_fields):
         '''
-        application : str
+        interface : str
         name : str
         role : str
-        subordinate : bool
+        '''
+        self.interface = interface
+        self.name = name
+        self.role = role
+
+
+
+class EndpointStatus(Type):
+    _toSchema = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
+    _toPy = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
+    def __init__(self, application=None, name=None, role=None, subordinate=None, **unknown_fields):
+        '''
+        application : str
+        name : str
+        role : str
+        subordinate : bool
         '''
         self.application = application
         self.name = name
@@ -2373,7 +3195,7 @@ class Entities(Type):
     _toPy = {'entities': 'entities'}
     def __init__(self, entities=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+        entities : typing.Sequence[~Entity]
         '''
         self.entities = [Entity.from_json(o) for o in entities or []]
 
@@ -2384,7 +3206,7 @@ class EntitiesCharmURL(Type):
     _toPy = {'entities': 'entities'}
     def __init__(self, entities=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~EntityCharmURL]<~EntityCharmURL>
+        entities : typing.Sequence[~EntityCharmURL]
         '''
         self.entities = [EntityCharmURL.from_json(o) for o in entities or []]
 
@@ -2395,7 +3217,7 @@ class EntitiesPortRanges(Type):
     _toPy = {'entities': 'entities'}
     def __init__(self, entities=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~EntityPortRange]<~EntityPortRange>
+        entities : typing.Sequence[~EntityPortRange]
         '''
         self.entities = [EntityPortRange.from_json(o) for o in entities or []]
 
@@ -2406,7 +3228,7 @@ class EntitiesResult(Type):
     _toPy = {'entities': 'entities', 'error': 'error'}
     def __init__(self, entities=None, error=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+        entities : typing.Sequence[~Entity]
         error : Error
         '''
         self.entities = [Entity.from_json(o) for o in entities or []]
@@ -2419,7 +3241,7 @@ class EntitiesResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~EntitiesResult]<~EntitiesResult>
+        results : typing.Sequence[~EntitiesResult]
         '''
         self.results = [EntitiesResult.from_json(o) for o in results or []]
 
@@ -2430,7 +3252,7 @@ class EntitiesVersion(Type):
     _toPy = {'agent-tools': 'agent_tools'}
     def __init__(self, agent_tools=None, **unknown_fields):
         '''
-        agent_tools : typing.Sequence<+T_co>[~EntityVersion]<~EntityVersion>
+        agent_tools : typing.Sequence[~EntityVersion]
         '''
         self.agent_tools = [EntityVersion.from_json(o) for o in agent_tools or []]
 
@@ -2441,7 +3263,7 @@ class EntitiesWatchResult(Type):
     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
         '''
-        changes : typing.Sequence<+T_co>[str]
+        changes : typing.Sequence[str]
         error : Error
         watcher_id : str
         '''
@@ -2467,7 +3289,7 @@ class EntityAnnotations(Type):
     _toPy = {'annotations': 'annotations', 'entity': 'entity'}
     def __init__(self, annotations=None, entity=None, **unknown_fields):
         '''
-        annotations : typing.Mapping<~KT, +VT_co>[str, str]
+        annotations : typing.Mapping[str, str]
         entity : str
         '''
         self.annotations = annotations
@@ -2488,13 +3310,37 @@ class EntityCharmURL(Type):
 
 
 
+class EntityMacaroonArg(Type):
+    _toSchema = {'macaroon': 'macaroon', 'tag': 'tag'}
+    _toPy = {'macaroon': 'macaroon', 'tag': 'tag'}
+    def __init__(self, macaroon=None, tag=None, **unknown_fields):
+        '''
+        macaroon : Macaroon
+        tag : str
+        '''
+        self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+        self.tag = tag
+
+
+
+class EntityMacaroonArgs(Type):
+    _toSchema = {'args': 'Args'}
+    _toPy = {'Args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~EntityMacaroonArg]
+        '''
+        self.args = [EntityMacaroonArg.from_json(o) for o in args or []]
+
+
+
 class EntityMetrics(Type):
     _toSchema = {'error': 'error', 'metrics': 'metrics'}
     _toPy = {'error': 'error', 'metrics': 'metrics'}
     def __init__(self, error=None, metrics=None, **unknown_fields):
         '''
         error : Error
-        metrics : typing.Sequence<+T_co>[~MetricResult]<~MetricResult>
+        metrics : typing.Sequence[~MetricResult]
         '''
         self.error = Error.from_json(error) if error else None
         self.metrics = [MetricResult.from_json(o) for o in metrics or []]
@@ -2519,7 +3365,7 @@ class EntityPasswords(Type):
     _toPy = {'changes': 'changes'}
     def __init__(self, changes=None, **unknown_fields):
         '''
-        changes : typing.Sequence<+T_co>[~EntityPassword]<~EntityPassword>
+        changes : typing.Sequence[~EntityPassword]
         '''
         self.changes = [EntityPassword.from_json(o) for o in changes or []]
 
@@ -2547,7 +3393,7 @@ class EntityStatus(Type):
     _toPy = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
     def __init__(self, data=None, info=None, since=None, status=None, **unknown_fields):
         '''
-        data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        data : typing.Mapping[str, typing.Any]
         info : str
         since : str
         status : str
@@ -2564,7 +3410,7 @@ class EntityStatusArgs(Type):
     _toPy = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
     def __init__(self, data=None, info=None, status=None, tag=None, **unknown_fields):
         '''
-        data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        data : typing.Mapping[str, typing.Any]
         info : str
         status : str
         tag : str
@@ -2576,6 +3422,19 @@ class EntityStatusArgs(Type):
 
 
 
+class EntityString(Type):
+    _toSchema = {'tag': 'tag', 'value': 'value'}
+    _toPy = {'tag': 'tag', 'value': 'value'}
+    def __init__(self, tag=None, value=None, **unknown_fields):
+        '''
+        tag : str
+        value : str
+        '''
+        self.tag = tag
+        self.value = value
+
+
+
 class EntityVersion(Type):
     _toSchema = {'tag': 'tag', 'tools': 'tools'}
     _toPy = {'tag': 'tag', 'tools': 'tools'}
@@ -2607,7 +3466,7 @@ class EntityWorkloadVersions(Type):
     _toPy = {'entities': 'entities'}
     def __init__(self, entities=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~EntityWorkloadVersion]<~EntityWorkloadVersion>
+        entities : typing.Sequence[~EntityWorkloadVersion]
         '''
         self.entities = [EntityWorkloadVersion.from_json(o) for o in entities or []]
 
@@ -2618,7 +3477,7 @@ class EnvListArgs(Type):
     _toPy = {'patterns': 'patterns'}
     def __init__(self, patterns=None, **unknown_fields):
         '''
-        patterns : typing.Sequence<+T_co>[str]
+        patterns : typing.Sequence[str]
         '''
         self.patterns = patterns
 
@@ -2629,7 +3488,7 @@ class EnvListResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~Payload]<~Payload>
+        results : typing.Sequence[~Payload]
         '''
         self.results = [Payload.from_json(o) for o in results or []]
 
@@ -2679,12 +3538,77 @@ class ErrorResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+        results : typing.Sequence[~ErrorResult]
         '''
         self.results = [ErrorResult.from_json(o) for o in results or []]
 
 
 
+class ExternalControllerInfo(Type):
+    _toSchema = {'addrs': 'addrs', 'ca_cert': 'ca-cert', 'controller_alias': 'controller-alias', 'controller_tag': 'controller-tag'}
+    _toPy = {'addrs': 'addrs', 'ca-cert': 'ca_cert', 'controller-alias': 'controller_alias', 'controller-tag': 'controller_tag'}
+    def __init__(self, addrs=None, ca_cert=None, controller_alias=None, controller_tag=None, **unknown_fields):
+        '''
+        addrs : typing.Sequence[str]
+        ca_cert : str
+        controller_alias : str
+        controller_tag : str
+        '''
+        self.addrs = addrs
+        self.ca_cert = ca_cert
+        self.controller_alias = controller_alias
+        self.controller_tag = controller_tag
+
+
+
+class ExternalControllerInfoResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : ExternalControllerInfo
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = ExternalControllerInfo.from_json(result) if result else None
+
+
+
+class ExternalControllerInfoResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ExternalControllerInfoResult]
+        '''
+        self.results = [ExternalControllerInfoResult.from_json(o) for o in results or []]
+
+
+
+class FanConfigEntry(Type):
+    _toSchema = {'overlay': 'overlay', 'underlay': 'underlay'}
+    _toPy = {'overlay': 'overlay', 'underlay': 'underlay'}
+    def __init__(self, overlay=None, underlay=None, **unknown_fields):
+        '''
+        overlay : str
+        underlay : str
+        '''
+        self.overlay = overlay
+        self.underlay = underlay
+
+
+
+class FanConfigResult(Type):
+    _toSchema = {'fans': 'fans'}
+    _toPy = {'fans': 'fans'}
+    def __init__(self, fans=None, **unknown_fields):
+        '''
+        fans : typing.Sequence[~FanConfigEntry]
+        '''
+        self.fans = [FanConfigEntry.from_json(o) for o in fans or []]
+
+
+
 class Filesystem(Type):
     _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'volume_tag': 'volume-tag'}
     _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'volume-tag': 'volume_tag'}
@@ -2782,7 +3706,7 @@ class FilesystemAttachmentParamsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~FilesystemAttachmentParamsResult]<~FilesystemAttachmentParamsResult>
+        results : typing.Sequence[~FilesystemAttachmentParamsResult]
         '''
         self.results = [FilesystemAttachmentParamsResult.from_json(o) for o in results or []]
 
@@ -2806,7 +3730,7 @@ class FilesystemAttachmentResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~FilesystemAttachmentResult]<~FilesystemAttachmentResult>
+        results : typing.Sequence[~FilesystemAttachmentResult]
         '''
         self.results = [FilesystemAttachmentResult.from_json(o) for o in results or []]
 
@@ -2817,7 +3741,7 @@ class FilesystemAttachments(Type):
     _toPy = {'filesystem-attachments': 'filesystem_attachments'}
     def __init__(self, filesystem_attachments=None, **unknown_fields):
         '''
-        filesystem_attachments : typing.Sequence<+T_co>[~FilesystemAttachment]<~FilesystemAttachment>
+        filesystem_attachments : typing.Sequence[~FilesystemAttachment]
         '''
         self.filesystem_attachments = [FilesystemAttachment.from_json(o) for o in filesystem_attachments or []]
 
@@ -2830,7 +3754,7 @@ class FilesystemDetails(Type):
         '''
         filesystem_tag : str
         info : FilesystemInfo
-        machine_attachments : typing.Mapping<~KT, +VT_co>[str, ~FilesystemAttachmentInfo]<~FilesystemAttachmentInfo>
+        machine_attachments : typing.Mapping[str, ~FilesystemAttachmentInfo]
         status : EntityStatus
         storage : StorageDetails
         volume_tag : str
@@ -2850,7 +3774,7 @@ class FilesystemDetailsListResult(Type):
     def __init__(self, error=None, result=None, **unknown_fields):
         '''
         error : Error
-        result : typing.Sequence<+T_co>[~FilesystemDetails]<~FilesystemDetails>
+        result : typing.Sequence[~FilesystemDetails]
         '''
         self.error = Error.from_json(error) if error else None
         self.result = [FilesystemDetails.from_json(o) for o in result or []]
@@ -2862,7 +3786,7 @@ class FilesystemDetailsListResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~FilesystemDetailsListResult]<~FilesystemDetailsListResult>
+        results : typing.Sequence[~FilesystemDetailsListResult]
         '''
         self.results = [FilesystemDetailsListResult.from_json(o) for o in results or []]
 
@@ -2873,7 +3797,7 @@ class FilesystemFilter(Type):
     _toPy = {'machines': 'machines'}
     def __init__(self, machines=None, **unknown_fields):
         '''
-        machines : typing.Sequence<+T_co>[str]
+        machines : typing.Sequence[str]
         '''
         self.machines = machines
 
@@ -2884,7 +3808,7 @@ class FilesystemFilters(Type):
     _toPy = {'filters': 'filters'}
     def __init__(self, filters=None, **unknown_fields):
         '''
-        filters : typing.Sequence<+T_co>[~FilesystemFilter]<~FilesystemFilter>
+        filters : typing.Sequence[~FilesystemFilter]
         '''
         self.filters = [FilesystemFilter.from_json(o) for o in filters or []]
 
@@ -2909,11 +3833,11 @@ class FilesystemParams(Type):
     def __init__(self, attachment=None, attributes=None, filesystem_tag=None, provider=None, size=None, tags=None, volume_tag=None, **unknown_fields):
         '''
         attachment : FilesystemAttachmentParams
-        attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        attributes : typing.Mapping[str, typing.Any]
         filesystem_tag : str
         provider : str
         size : int
-        tags : typing.Mapping<~KT, +VT_co>[str, str]
+        tags : typing.Mapping[str, str]
         volume_tag : str
         '''
         self.attachment = FilesystemAttachmentParams.from_json(attachment) if attachment else None
@@ -2944,7 +3868,7 @@ class FilesystemParamsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~FilesystemParamsResult]<~FilesystemParamsResult>
+        results : typing.Sequence[~FilesystemParamsResult]
         '''
         self.results = [FilesystemParamsResult.from_json(o) for o in results or []]
 
@@ -2968,7 +3892,7 @@ class FilesystemResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~FilesystemResult]<~FilesystemResult>
+        results : typing.Sequence[~FilesystemResult]
         '''
         self.results = [FilesystemResult.from_json(o) for o in results or []]
 
@@ -2979,7 +3903,7 @@ class Filesystems(Type):
     _toPy = {'filesystems': 'filesystems'}
     def __init__(self, filesystems=None, **unknown_fields):
         '''
-        filesystems : typing.Sequence<+T_co>[~Filesystem]<~Filesystem>
+        filesystems : typing.Sequence[~Filesystem]
         '''
         self.filesystems = [Filesystem.from_json(o) for o in filesystems or []]
 
@@ -2990,7 +3914,7 @@ class FindActionsByNames(Type):
     _toPy = {'names': 'names'}
     def __init__(self, names=None, **unknown_fields):
         '''
-        names : typing.Sequence<+T_co>[str]
+        names : typing.Sequence[str]
         '''
         self.names = names
 
@@ -3001,7 +3925,7 @@ class FindTags(Type):
     _toPy = {'prefixes': 'prefixes'}
     def __init__(self, prefixes=None, **unknown_fields):
         '''
-        prefixes : typing.Sequence<+T_co>[str]
+        prefixes : typing.Sequence[str]
         '''
         self.prefixes = prefixes
 
@@ -3012,7 +3936,7 @@ class FindTagsResults(Type):
     _toPy = {'matches': 'matches'}
     def __init__(self, matches=None, **unknown_fields):
         '''
-        matches : typing.Sequence<+T_co>[~Entity]<~Entity>
+        matches : typing.Sequence[~Entity]
         '''
         self.matches = [Entity.from_json(o) for o in matches or []]
 
@@ -3043,27 +3967,55 @@ class FindToolsResult(Type):
     def __init__(self, error=None, list_=None, **unknown_fields):
         '''
         error : Error
-        list_ : typing.Sequence<+T_co>[~Tools]<~Tools>
+        list_ : typing.Sequence[~Tools]
         '''
         self.error = Error.from_json(error) if error else None
         self.list_ = [Tools.from_json(o) for o in list_ or []]
 
 
 
+class FirewallRule(Type):
+    _toSchema = {'known_service': 'known-service', 'whitelist_cidrs': 'whitelist-cidrs'}
+    _toPy = {'known-service': 'known_service', 'whitelist-cidrs': 'whitelist_cidrs'}
+    def __init__(self, known_service=None, whitelist_cidrs=None, **unknown_fields):
+        '''
+        known_service : str
+        whitelist_cidrs : typing.Sequence[str]
+        '''
+        self.known_service = known_service
+        self.whitelist_cidrs = whitelist_cidrs
+
+
+
+class FirewallRuleArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~FirewallRule]
+        '''
+        self.args = [FirewallRule.from_json(o) for o in args or []]
+
+
+
 class FullStatus(Type):
-    _toSchema = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote_applications': 'remote-applications'}
-    _toPy = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote-applications': 'remote_applications'}
-    def __init__(self, applications=None, machines=None, model=None, relations=None, remote_applications=None, **unknown_fields):
+    _toSchema = {'applications': 'applications', 'controller_timestamp': 'controller-timestamp', 'machines': 'machines', 'model': 'model', 'offers': 'offers', 'relations': 'relations', 'remote_applications': 'remote-applications'}
+    _toPy = {'applications': 'applications', 'controller-timestamp': 'controller_timestamp', 'machines': 'machines', 'model': 'model', 'offers': 'offers', 'relations': 'relations', 'remote-applications': 'remote_applications'}
+    def __init__(self, applications=None, controller_timestamp=None, machines=None, model=None, offers=None, relations=None, remote_applications=None, **unknown_fields):
         '''
-        applications : typing.Mapping<~KT, +VT_co>[str, ~ApplicationStatus]<~ApplicationStatus>
-        machines : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
+        applications : typing.Mapping[str, ~ApplicationStatus]
+        controller_timestamp : str
+        machines : typing.Mapping[str, ~MachineStatus]
         model : ModelStatusInfo
-        relations : typing.Sequence<+T_co>[~RelationStatus]<~RelationStatus>
-        remote_applications : typing.Mapping<~KT, +VT_co>[str, ~RemoteApplicationStatus]<~RemoteApplicationStatus>
+        offers : typing.Mapping[str, ~ApplicationOfferStatus]
+        relations : typing.Sequence[~RelationStatus]
+        remote_applications : typing.Mapping[str, ~RemoteApplicationStatus]
         '''
         self.applications = applications
+        self.controller_timestamp = controller_timestamp
         self.machines = machines
         self.model = ModelStatusInfo.from_json(model) if model else None
+        self.offers = offers
         self.relations = [RelationStatus.from_json(o) for o in relations or []]
         self.remote_applications = remote_applications
 
@@ -3096,7 +4048,7 @@ class GetLeadershipSettingsBulkResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~GetLeadershipSettingsResult]<~GetLeadershipSettingsResult>
+        results : typing.Sequence[~GetLeadershipSettingsResult]
         '''
         self.results = [GetLeadershipSettingsResult.from_json(o) for o in results or []]
 
@@ -3108,13 +4060,85 @@ class GetLeadershipSettingsResult(Type):
     def __init__(self, error=None, settings=None, **unknown_fields):
         '''
         error : Error
-        settings : typing.Mapping<~KT, +VT_co>[str, str]
+        settings : typing.Mapping[str, str]
         '''
         self.error = Error.from_json(error) if error else None
         self.settings = settings
 
 
 
+class GetTokenArg(Type):
+    _toSchema = {'tag': 'tag'}
+    _toPy = {'tag': 'tag'}
+    def __init__(self, tag=None, **unknown_fields):
+        '''
+        tag : str
+        '''
+        self.tag = tag
+
+
+
+class GetTokenArgs(Type):
+    _toSchema = {'args': 'Args'}
+    _toPy = {'Args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~GetTokenArg]
+        '''
+        self.args = [GetTokenArg.from_json(o) for o in args or []]
+
+
+
+class GoalState(Type):
+    _toSchema = {'relations': 'relations', 'units': 'units'}
+    _toPy = {'relations': 'relations', 'units': 'units'}
+    def __init__(self, relations=None, units=None, **unknown_fields):
+        '''
+        relations : typing.Mapping[str, typing.Any]
+        units : typing.Mapping[str, ~GoalStateStatus]
+        '''
+        self.relations = relations
+        self.units = units
+
+
+
+class GoalStateResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : GoalState
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = GoalState.from_json(result) if result else None
+
+
+
+class GoalStateResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~GoalStateResult]
+        '''
+        self.results = [GoalStateResult.from_json(o) for o in results or []]
+
+
+
+class GoalStateStatus(Type):
+    _toSchema = {'since': 'since', 'status': 'status'}
+    _toPy = {'since': 'since', 'status': 'status'}
+    def __init__(self, since=None, status=None, **unknown_fields):
+        '''
+        since : str
+        status : str
+        '''
+        self.since = since
+        self.status = status
+
+
+
 class HAMember(Type):
     _toSchema = {'public_address': 'public-address', 'series': 'series', 'tag': 'tag'}
     _toPy = {'public-address': 'public_address', 'series': 'series', 'tag': 'tag'}
@@ -3141,7 +4165,7 @@ class HardwareCharacteristics(Type):
         cpu_power : int
         mem : int
         root_disk : int
-        tags : typing.Sequence<+T_co>[str]
+        tags : typing.Sequence[str]
         '''
         self.arch = arch
         self.availability_zone = availability_zone
@@ -3159,7 +4183,7 @@ class History(Type):
     def __init__(self, error=None, statuses=None, **unknown_fields):
         '''
         error : Error
-        statuses : typing.Sequence<+T_co>[~DetailedStatus]<~DetailedStatus>
+        statuses : typing.Sequence[~DetailedStatus]
         '''
         self.error = Error.from_json(error) if error else None
         self.statuses = [DetailedStatus.from_json(o) for o in statuses or []]
@@ -3172,7 +4196,7 @@ class HostNetworkChange(Type):
     def __init__(self, error=None, new_bridges=None, reconfigure_delay=None, **unknown_fields):
         '''
         error : Error
-        new_bridges : typing.Sequence<+T_co>[~DeviceBridgeInfo]<~DeviceBridgeInfo>
+        new_bridges : typing.Sequence[~DeviceBridgeInfo]
         reconfigure_delay : int
         '''
         self.error = Error.from_json(error) if error else None
@@ -3186,7 +4210,7 @@ class HostNetworkChangeResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~HostNetworkChange]<~HostNetworkChange>
+        results : typing.Sequence[~HostNetworkChange]
         '''
         self.results = [HostNetworkChange.from_json(o) for o in results or []]
 
@@ -3211,7 +4235,7 @@ class HostedModelConfig(Type):
     def __init__(self, cloud_spec=None, config=None, error=None, name=None, owner=None, **unknown_fields):
         '''
         cloud_spec : CloudSpec
-        config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        config : typing.Mapping[str, typing.Any]
         error : Error
         name : str
         owner : str
@@ -3229,7 +4253,7 @@ class HostedModelConfigsResults(Type):
     _toPy = {'models': 'models'}
     def __init__(self, models=None, **unknown_fields):
         '''
-        models : typing.Sequence<+T_co>[~HostedModelConfig]<~HostedModelConfig>
+        models : typing.Sequence[~HostedModelConfig]
         '''
         self.models = [HostedModelConfig.from_json(o) for o in models or []]
 
@@ -3240,7 +4264,7 @@ class ImageFilterParams(Type):
     _toPy = {'images': 'images'}
     def __init__(self, images=None, **unknown_fields):
         '''
-        images : typing.Sequence<+T_co>[~ImageSpec]<~ImageSpec>
+        images : typing.Sequence[~ImageSpec]
         '''
         self.images = [ImageSpec.from_json(o) for o in images or []]
 
@@ -3270,10 +4294,10 @@ class ImageMetadataFilter(Type):
     _toPy = {'arches': 'arches', 'region': 'region', 'root-storage-type': 'root_storage_type', 'series': 'series', 'stream': 'stream', 'virt-type': 'virt_type'}
     def __init__(self, arches=None, region=None, root_storage_type=None, series=None, stream=None, virt_type=None, **unknown_fields):
         '''
-        arches : typing.Sequence<+T_co>[str]
+        arches : typing.Sequence[str]
         region : str
         root_storage_type : str
-        series : typing.Sequence<+T_co>[str]
+        series : typing.Sequence[str]
         stream : str
         virt_type : str
         '''
@@ -3301,12 +4325,94 @@ class ImageSpec(Type):
 
 
 
+class ImportStorageDetails(Type):
+    _toSchema = {'storage_tag': 'storage-tag'}
+    _toPy = {'storage-tag': 'storage_tag'}
+    def __init__(self, storage_tag=None, **unknown_fields):
+        '''
+        storage_tag : str
+        '''
+        self.storage_tag = storage_tag
+
+
+
+class ImportStorageParams(Type):
+    _toSchema = {'kind': 'kind', 'pool': 'pool', 'provider_id': 'provider-id', 'storage_name': 'storage-name'}
+    _toPy = {'kind': 'kind', 'pool': 'pool', 'provider-id': 'provider_id', 'storage-name': 'storage_name'}
+    def __init__(self, kind=None, pool=None, provider_id=None, storage_name=None, **unknown_fields):
+        '''
+        kind : int
+        pool : str
+        provider_id : str
+        storage_name : str
+        '''
+        self.kind = kind
+        self.pool = pool
+        self.provider_id = provider_id
+        self.storage_name = storage_name
+
+
+
+class ImportStorageResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : ImportStorageDetails
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = ImportStorageDetails.from_json(result) if result else None
+
+
+
+class ImportStorageResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ImportStorageResult]
+        '''
+        self.results = [ImportStorageResult.from_json(o) for o in results or []]
+
+
+
+class IngressNetworksChangeEvent(Type):
+    _toSchema = {'application_token': 'application-token', 'ingress_required': 'ingress-required', 'macaroons': 'macaroons', 'networks': 'networks', 'relation_token': 'relation-token'}
+    _toPy = {'application-token': 'application_token', 'ingress-required': 'ingress_required', 'macaroons': 'macaroons', 'networks': 'networks', 'relation-token': 'relation_token'}
+    def __init__(self, application_token=None, ingress_required=None, macaroons=None, networks=None, relation_token=None, **unknown_fields):
+        '''
+        application_token : str
+        ingress_required : bool
+        macaroons : typing.Sequence[~Macaroon]
+        networks : typing.Sequence[str]
+        relation_token : str
+        '''
+        self.application_token = application_token
+        self.ingress_required = ingress_required
+        self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+        self.networks = networks
+        self.relation_token = relation_token
+
+
+
+class IngressNetworksChanges(Type):
+    _toSchema = {'changes': 'changes'}
+    _toPy = {'changes': 'changes'}
+    def __init__(self, changes=None, **unknown_fields):
+        '''
+        changes : typing.Sequence[~IngressNetworksChangeEvent]
+        '''
+        self.changes = [IngressNetworksChangeEvent.from_json(o) for o in changes or []]
+
+
+
 class InitiateMigrationArgs(Type):
     _toSchema = {'specs': 'specs'}
     _toPy = {'specs': 'specs'}
     def __init__(self, specs=None, **unknown_fields):
         '''
-        specs : typing.Sequence<+T_co>[~MigrationSpec]<~MigrationSpec>
+        specs : typing.Sequence[~MigrationSpec]
         '''
         self.specs = [MigrationSpec.from_json(o) for o in specs or []]
 
@@ -3332,7 +4438,7 @@ class InitiateMigrationResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~InitiateMigrationResult]<~InitiateMigrationResult>
+        results : typing.Sequence[~InitiateMigrationResult]
         '''
         self.results = [InitiateMigrationResult.from_json(o) for o in results or []]
 
@@ -3345,11 +4451,11 @@ class InstanceInfo(Type):
         '''
         characteristics : HardwareCharacteristics
         instance_id : str
-        network_config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+        network_config : typing.Sequence[~NetworkConfig]
         nonce : str
         tag : str
-        volume_attachments : typing.Mapping<~KT, +VT_co>[str, ~VolumeAttachmentInfo]<~VolumeAttachmentInfo>
-        volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
+        volume_attachments : typing.Mapping[str, ~VolumeAttachmentInfo]
+        volumes : typing.Sequence[~Volume]
         '''
         self.characteristics = HardwareCharacteristics.from_json(characteristics) if characteristics else None
         self.instance_id = instance_id
@@ -3366,7 +4472,7 @@ class InstanceType(Type):
     _toPy = {'arches': 'arches', 'cost': 'cost', 'cpu-cores': 'cpu_cores', 'deprecated': 'deprecated', 'memory': 'memory', 'name': 'name', 'root-disk': 'root_disk', 'virt-type': 'virt_type'}
     def __init__(self, arches=None, cost=None, cpu_cores=None, deprecated=None, memory=None, name=None, root_disk=None, virt_type=None, **unknown_fields):
         '''
-        arches : typing.Sequence<+T_co>[str]
+        arches : typing.Sequence[str]
         cost : int
         cpu_cores : int
         deprecated : bool
@@ -3395,7 +4501,7 @@ class InstanceTypesResult(Type):
         cost_divisor : int
         cost_unit : str
         error : Error
-        instance_types : typing.Sequence<+T_co>[~InstanceType]<~InstanceType>
+        instance_types : typing.Sequence[~InstanceType]
         '''
         self.cost_currency = cost_currency
         self.cost_divisor = cost_divisor
@@ -3410,7 +4516,7 @@ class InstanceTypesResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~InstanceTypesResult]<~InstanceTypesResult>
+        results : typing.Sequence[~InstanceTypesResult]
         '''
         self.results = [InstanceTypesResult.from_json(o) for o in results or []]
 
@@ -3421,7 +4527,7 @@ class InstancesInfo(Type):
     _toPy = {'machines': 'machines'}
     def __init__(self, machines=None, **unknown_fields):
         '''
-        machines : typing.Sequence<+T_co>[~InstanceInfo]<~InstanceInfo>
+        machines : typing.Sequence[~InstanceInfo]
         '''
         self.machines = [InstanceInfo.from_json(o) for o in machines or []]
 
@@ -3445,7 +4551,7 @@ class IntResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~IntResult]<~IntResult>
+        results : typing.Sequence[~IntResult]
         '''
         self.results = [IntResult.from_json(o) for o in results or []]
 
@@ -3464,6 +4570,17 @@ class InterfaceAddress(Type):
 
 
 
+class InvalidateCredentialArg(Type):
+    _toSchema = {'reason': 'reason'}
+    _toPy = {'reason': 'reason'}
+    def __init__(self, reason=None, **unknown_fields):
+        '''
+        reason : str
+        '''
+        self.reason = reason
+
+
+
 class IsMasterResult(Type):
     _toSchema = {'master': 'master'}
     _toPy = {'master': 'master'}
@@ -3492,7 +4609,7 @@ class JobsResult(Type):
     def __init__(self, error=None, jobs=None, **unknown_fields):
         '''
         error : Error
-        jobs : typing.Sequence<+T_co>[str]
+        jobs : typing.Sequence[str]
         '''
         self.error = Error.from_json(error) if error else None
         self.jobs = jobs
@@ -3504,70 +4621,380 @@ class JobsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~JobsResult]<~JobsResult>
+        results : typing.Sequence[~JobsResult]
         '''
         self.results = [JobsResult.from_json(o) for o in results or []]
 
 
 
-class LifeResult(Type):
-    _toSchema = {'error': 'error', 'life': 'life'}
-    _toPy = {'error': 'error', 'life': 'life'}
-    def __init__(self, error=None, life=None, **unknown_fields):
+class KnownServiceArgs(Type):
+    _toSchema = {'known_services': 'known-services'}
+    _toPy = {'known-services': 'known_services'}
+    def __init__(self, known_services=None, **unknown_fields):
         '''
-        error : Error
-        life : str
+        known_services : typing.Sequence[str]
         '''
-        self.error = Error.from_json(error) if error else None
-        self.life = life
+        self.known_services = known_services
 
 
 
-class LifeResults(Type):
-    _toSchema = {'results': 'results'}
-    _toPy = {'results': 'results'}
-    def __init__(self, results=None, **unknown_fields):
+class KubernetesDeviceParams(Type):
+    _toSchema = {'attributes': 'Attributes', 'count': 'Count', 'type_': 'Type'}
+    _toPy = {'Attributes': 'attributes', 'Count': 'count', 'Type': 'type_'}
+    def __init__(self, attributes=None, count=None, type_=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
+        attributes : typing.Mapping[str, str]
+        count : int
+        type_ : str
         '''
-        self.results = [LifeResult.from_json(o) for o in results or []]
+        self.attributes = attributes
+        self.count = count
+        self.type_ = type_
 
 
 
-class ListCloudImageMetadataResult(Type):
-    _toSchema = {'result': 'result'}
-    _toPy = {'result': 'result'}
-    def __init__(self, result=None, **unknown_fields):
+class KubernetesFilesystemAttachmentParams(Type):
+    _toSchema = {'mount_point': 'mount-point', 'provider': 'provider', 'read_only': 'read-only'}
+    _toPy = {'mount-point': 'mount_point', 'provider': 'provider', 'read-only': 'read_only'}
+    def __init__(self, mount_point=None, provider=None, read_only=None, **unknown_fields):
         '''
-        result : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
+        mount_point : str
+        provider : str
+        read_only : bool
         '''
-        self.result = [CloudImageMetadata.from_json(o) for o in result or []]
+        self.mount_point = mount_point
+        self.provider = provider
+        self.read_only = read_only
 
 
 
-class ListImageResult(Type):
-    _toSchema = {'result': 'result'}
-    _toPy = {'result': 'result'}
-    def __init__(self, result=None, **unknown_fields):
+class KubernetesFilesystemInfo(Type):
+    _toSchema = {'data': 'data', 'filesystem_id': 'filesystem-id', 'info': 'info', 'mount_point': 'mount-point', 'pool': 'pool', 'read_only': 'read-only', 'size': 'size', 'status': 'status', 'storagename': 'storagename', 'volume': 'volume'}
+    _toPy = {'data': 'data', 'filesystem-id': 'filesystem_id', 'info': 'info', 'mount-point': 'mount_point', 'pool': 'pool', 'read-only': 'read_only', 'size': 'size', 'status': 'status', 'storagename': 'storagename', 'volume': 'volume'}
+    def __init__(self, data=None, filesystem_id=None, info=None, mount_point=None, pool=None, read_only=None, size=None, status=None, storagename=None, volume=None, **unknown_fields):
         '''
-        result : typing.Sequence<+T_co>[~ImageMetadata]<~ImageMetadata>
+        data : typing.Mapping[str, typing.Any]
+        filesystem_id : str
+        info : str
+        mount_point : str
+        pool : str
+        read_only : bool
+        size : int
+        status : str
+        storagename : str
+        volume : KubernetesVolumeInfo
         '''
-        self.result = [ImageMetadata.from_json(o) for o in result or []]
+        self.data = data
+        self.filesystem_id = filesystem_id
+        self.info = info
+        self.mount_point = mount_point
+        self.pool = pool
+        self.read_only = read_only
+        self.size = size
+        self.status = status
+        self.storagename = storagename
+        self.volume = KubernetesVolumeInfo.from_json(volume) if volume else None
 
 
 
-class ListResourcesArgs(Type):
-    _toSchema = {'entities': 'entities'}
-    _toPy = {'entities': 'entities'}
-    def __init__(self, entities=None, **unknown_fields):
+class KubernetesFilesystemParams(Type):
+    _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+    _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+    def __init__(self, attachment=None, attributes=None, provider=None, size=None, storagename=None, tags=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+        attachment : KubernetesFilesystemAttachmentParams
+        attributes : typing.Mapping[str, typing.Any]
+        provider : str
+        size : int
+        storagename : str
+        tags : typing.Mapping[str, str]
         '''
-        self.entities = [Entity.from_json(o) for o in entities or []]
+        self.attachment = KubernetesFilesystemAttachmentParams.from_json(attachment) if attachment else None
+        self.attributes = attributes
+        self.provider = provider
+        self.size = size
+        self.storagename = storagename
+        self.tags = tags
 
 
 
-class ListSSHKeys(Type):
+class KubernetesProvisioningInfo(Type):
+    _toSchema = {'constraints': 'constraints', 'devices': 'devices', 'filesystems': 'filesystems', 'placement': 'placement', 'pod_spec': 'pod-spec', 'tags': 'tags', 'volumes': 'volumes'}
+    _toPy = {'constraints': 'constraints', 'devices': 'devices', 'filesystems': 'filesystems', 'placement': 'placement', 'pod-spec': 'pod_spec', 'tags': 'tags', 'volumes': 'volumes'}
+    def __init__(self, constraints=None, devices=None, filesystems=None, placement=None, pod_spec=None, tags=None, volumes=None, **unknown_fields):
+        '''
+        constraints : Value
+        devices : typing.Sequence[~KubernetesDeviceParams]
+        filesystems : typing.Sequence[~KubernetesFilesystemParams]
+        placement : str
+        pod_spec : str
+        tags : typing.Mapping[str, str]
+        volumes : typing.Sequence[~KubernetesVolumeParams]
+        '''
+        self.constraints = Value.from_json(constraints) if constraints else None
+        self.devices = [KubernetesDeviceParams.from_json(o) for o in devices or []]
+        self.filesystems = [KubernetesFilesystemParams.from_json(o) for o in filesystems or []]
+        self.placement = placement
+        self.pod_spec = pod_spec
+        self.tags = tags
+        self.volumes = [KubernetesVolumeParams.from_json(o) for o in volumes or []]
+
+
+
+class KubernetesProvisioningInfoResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : KubernetesProvisioningInfo
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = KubernetesProvisioningInfo.from_json(result) if result else None
+
+
+
+class KubernetesProvisioningInfoResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~KubernetesProvisioningInfoResult]
+        '''
+        self.results = [KubernetesProvisioningInfoResult.from_json(o) for o in results or []]
+
+
+
+class KubernetesVolumeAttachmentParams(Type):
+    _toSchema = {'provider': 'provider', 'read_only': 'read-only'}
+    _toPy = {'provider': 'provider', 'read-only': 'read_only'}
+    def __init__(self, provider=None, read_only=None, **unknown_fields):
+        '''
+        provider : str
+        read_only : bool
+        '''
+        self.provider = provider
+        self.read_only = read_only
+
+
+
+class KubernetesVolumeInfo(Type):
+    _toSchema = {'data': 'data', 'info': 'info', 'persistent': 'persistent', 'pool': 'pool', 'size': 'size', 'status': 'status', 'volume_id': 'volume-id'}
+    _toPy = {'data': 'data', 'info': 'info', 'persistent': 'persistent', 'pool': 'pool', 'size': 'size', 'status': 'status', 'volume-id': 'volume_id'}
+    def __init__(self, data=None, info=None, persistent=None, pool=None, size=None, status=None, volume_id=None, **unknown_fields):
+        '''
+        data : typing.Mapping[str, typing.Any]
+        info : str
+        persistent : bool
+        pool : str
+        size : int
+        status : str
+        volume_id : str
+        '''
+        self.data = data
+        self.info = info
+        self.persistent = persistent
+        self.pool = pool
+        self.size = size
+        self.status = status
+        self.volume_id = volume_id
+
+
+
+class KubernetesVolumeParams(Type):
+    _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+    _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+    def __init__(self, attachment=None, attributes=None, provider=None, size=None, storagename=None, tags=None, **unknown_fields):
+        '''
+        attachment : KubernetesVolumeAttachmentParams
+        attributes : typing.Mapping[str, typing.Any]
+        provider : str
+        size : int
+        storagename : str
+        tags : typing.Mapping[str, str]
+        '''
+        self.attachment = KubernetesVolumeAttachmentParams.from_json(attachment) if attachment else None
+        self.attributes = attributes
+        self.provider = provider
+        self.size = size
+        self.storagename = storagename
+        self.tags = tags
+
+
+
+class LXDProfile(Type):
+    _toSchema = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+    _toPy = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+    def __init__(self, config=None, description=None, devices=None, **unknown_fields):
+        '''
+        config : typing.Mapping[str, str]
+        description : str
+        devices : typing.Mapping[str, typing.Any]
+        '''
+        self.config = config
+        self.description = description
+        self.devices = devices
+
+
+
+class LXDProfileUpgradeMessages(Type):
+    _toSchema = {'application': 'application', 'watcher_id': 'watcher-id'}
+    _toPy = {'application': 'application', 'watcher-id': 'watcher_id'}
+    def __init__(self, application=None, watcher_id=None, **unknown_fields):
+        '''
+        application : Entity
+        watcher_id : str
+        '''
+        self.application = Entity.from_json(application) if application else None
+        self.watcher_id = watcher_id
+
+
+
+class LXDProfileUpgradeMessagesResult(Type):
+    _toSchema = {'error': 'error', 'message': 'message', 'unit_name': 'unit-name'}
+    _toPy = {'error': 'error', 'message': 'message', 'unit-name': 'unit_name'}
+    def __init__(self, error=None, message=None, unit_name=None, **unknown_fields):
+        '''
+        error : Error
+        message : str
+        unit_name : str
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.message = message
+        self.unit_name = unit_name
+
+
+
+class LXDProfileUpgradeMessagesResults(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~LXDProfileUpgradeMessagesResult]
+        '''
+        self.args = [LXDProfileUpgradeMessagesResult.from_json(o) for o in args or []]
+
+
+
+class LifeResult(Type):
+    _toSchema = {'error': 'error', 'life': 'life'}
+    _toPy = {'error': 'error', 'life': 'life'}
+    def __init__(self, error=None, life=None, **unknown_fields):
+        '''
+        error : Error
+        life : str
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.life = life
+
+
+
+class LifeResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~LifeResult]
+        '''
+        self.results = [LifeResult.from_json(o) for o in results or []]
+
+
+
+class ListCloudImageMetadataResult(Type):
+    _toSchema = {'result': 'result'}
+    _toPy = {'result': 'result'}
+    def __init__(self, result=None, **unknown_fields):
+        '''
+        result : typing.Sequence[~CloudImageMetadata]
+        '''
+        self.result = [CloudImageMetadata.from_json(o) for o in result or []]
+
+
+
+class ListCloudInfo(Type):
+    _toSchema = {'clouddetails': 'CloudDetails', 'user_access': 'user-access'}
+    _toPy = {'CloudDetails': 'clouddetails', 'user-access': 'user_access'}
+    def __init__(self, clouddetails=None, user_access=None, **unknown_fields):
+        '''
+        clouddetails : CloudDetails
+        user_access : str
+        '''
+        self.clouddetails = CloudDetails.from_json(clouddetails) if clouddetails else None
+        self.user_access = user_access
+
+
+
+class ListCloudInfoResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : ListCloudInfo
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = ListCloudInfo.from_json(result) if result else None
+
+
+
+class ListCloudInfoResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ListCloudInfoResult]
+        '''
+        self.results = [ListCloudInfoResult.from_json(o) for o in results or []]
+
+
+
+class ListCloudsRequest(Type):
+    _toSchema = {'all_': 'all', 'user_tag': 'user-tag'}
+    _toPy = {'all': 'all_', 'user-tag': 'user_tag'}
+    def __init__(self, all_=None, user_tag=None, **unknown_fields):
+        '''
+        all_ : bool
+        user_tag : str
+        '''
+        self.all_ = all_
+        self.user_tag = user_tag
+
+
+
+class ListFirewallRulesResults(Type):
+    _toSchema = {'rules': 'Rules'}
+    _toPy = {'Rules': 'rules'}
+    def __init__(self, rules=None, **unknown_fields):
+        '''
+        rules : typing.Sequence[~FirewallRule]
+        '''
+        self.rules = [FirewallRule.from_json(o) for o in rules or []]
+
+
+
+class ListImageResult(Type):
+    _toSchema = {'result': 'result'}
+    _toPy = {'result': 'result'}
+    def __init__(self, result=None, **unknown_fields):
+        '''
+        result : typing.Sequence[~ImageMetadata]
+        '''
+        self.result = [ImageMetadata.from_json(o) for o in result or []]
+
+
+
+class ListResourcesArgs(Type):
+    _toSchema = {'entities': 'entities'}
+    _toPy = {'entities': 'entities'}
+    def __init__(self, entities=None, **unknown_fields):
+        '''
+        entities : typing.Sequence[~Entity]
+        '''
+        self.entities = [Entity.from_json(o) for o in entities or []]
+
+
+
+class ListSSHKeys(Type):
     _toSchema = {'entities': 'entities', 'mode': 'mode'}
     _toPy = {'entities': 'entities', 'mode': 'mode'}
     def __init__(self, entities=None, mode=None, **unknown_fields):
@@ -3585,7 +5012,7 @@ class ListSpacesResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~Space]<~Space>
+        results : typing.Sequence[~Space]
         '''
         self.results = [Space.from_json(o) for o in results or []]
 
@@ -3596,7 +5023,7 @@ class ListSubnetsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+        results : typing.Sequence[~Subnet]
         '''
         self.results = [Subnet.from_json(o) for o in results or []]
 
@@ -3607,7 +5034,7 @@ class ListUnitResourcesArgs(Type):
     _toPy = {'resource-names': 'resource_names'}
     def __init__(self, resource_names=None, **unknown_fields):
         '''
-        resource_names : typing.Sequence<+T_co>[str]
+        resource_names : typing.Sequence[str]
         '''
         self.resource_names = resource_names
 
@@ -3618,7 +5045,7 @@ class LogForwardingGetLastSentParams(Type):
     _toPy = {'ids': 'ids'}
     def __init__(self, ids=None, **unknown_fields):
         '''
-        ids : typing.Sequence<+T_co>[~LogForwardingID]<~LogForwardingID>
+        ids : typing.Sequence[~LogForwardingID]
         '''
         self.ids = [LogForwardingID.from_json(o) for o in ids or []]
 
@@ -3644,7 +5071,7 @@ class LogForwardingGetLastSentResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~LogForwardingGetLastSentResult]<~LogForwardingGetLastSentResult>
+        results : typing.Sequence[~LogForwardingGetLastSentResult]
         '''
         self.results = [LogForwardingGetLastSentResult.from_json(o) for o in results or []]
 
@@ -3683,7 +5110,7 @@ class LogForwardingSetLastSentParams(Type):
     _toPy = {'params': 'params'}
     def __init__(self, params=None, **unknown_fields):
         '''
-        params : typing.Sequence<+T_co>[~LogForwardingSetLastSentParam]<~LogForwardingSetLastSentParam>
+        params : typing.Sequence[~LogForwardingSetLastSentParam]
         '''
         self.params = [LogForwardingSetLastSentParam.from_json(o) for o in params or []]
 
@@ -3707,7 +5134,7 @@ class LookUpArgs(Type):
     _toPy = {'args': 'args'}
     def __init__(self, args=None, **unknown_fields):
         '''
-        args : typing.Sequence<+T_co>[~LookUpArg]<~LookUpArg>
+        args : typing.Sequence[~LookUpArg]
         '''
         self.args = [LookUpArg.from_json(o) for o in args or []]
 
@@ -3731,7 +5158,7 @@ class LookUpPayloadArgs(Type):
     _toPy = {'args': 'args'}
     def __init__(self, args=None, **unknown_fields):
         '''
-        args : typing.Sequence<+T_co>[~LookUpPayloadArg]<~LookUpPayloadArg>
+        args : typing.Sequence[~LookUpPayloadArg]
         '''
         self.args = [LookUpPayloadArg.from_json(o) for o in args or []]
 
@@ -3748,12 +5175,36 @@ class Macaroon(Type):
 
 
 
+class MacaroonResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : Macaroon
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = Macaroon.from_json(result) if result else None
+
+
+
+class MacaroonResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~MacaroonResult]
+        '''
+        self.results = [MacaroonResult.from_json(o) for o in results or []]
+
+
+
 class MachineAddresses(Type):
     _toSchema = {'addresses': 'addresses', 'tag': 'tag'}
     _toPy = {'addresses': 'addresses', 'tag': 'tag'}
     def __init__(self, addresses=None, tag=None, **unknown_fields):
         '''
-        addresses : typing.Sequence<+T_co>[~Address]<~Address>
+        addresses : typing.Sequence[~Address]
         tag : str
         '''
         self.addresses = [Address.from_json(o) for o in addresses or []]
@@ -3766,7 +5217,7 @@ class MachineAddressesResult(Type):
     _toPy = {'addresses': 'addresses', 'error': 'error'}
     def __init__(self, addresses=None, error=None, **unknown_fields):
         '''
-        addresses : typing.Sequence<+T_co>[~Address]<~Address>
+        addresses : typing.Sequence[~Address]
         error : Error
         '''
         self.addresses = [Address.from_json(o) for o in addresses or []]
@@ -3779,7 +5230,7 @@ class MachineAddressesResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~MachineAddressesResult]<~MachineAddressesResult>
+        results : typing.Sequence[~MachineAddressesResult]
         '''
         self.results = [MachineAddressesResult.from_json(o) for o in results or []]
 
@@ -3790,7 +5241,7 @@ class MachineBlockDevices(Type):
     _toPy = {'block-devices': 'block_devices', 'machine': 'machine'}
     def __init__(self, block_devices=None, machine=None, **unknown_fields):
         '''
-        block_devices : typing.Sequence<+T_co>[~BlockDevice]<~BlockDevice>
+        block_devices : typing.Sequence[~BlockDevice]
         machine : str
         '''
         self.block_devices = [BlockDevice.from_json(o) for o in block_devices or []]
@@ -3803,7 +5254,7 @@ class MachineContainers(Type):
     _toPy = {'container-types': 'container_types', 'machine-tag': 'machine_tag'}
     def __init__(self, container_types=None, machine_tag=None, **unknown_fields):
         '''
-        container_types : typing.Sequence<+T_co>[str]
+        container_types : typing.Sequence[str]
         machine_tag : str
         '''
         self.container_types = container_types
@@ -3816,7 +5267,7 @@ class MachineContainersParams(Type):
     _toPy = {'params': 'params'}
     def __init__(self, params=None, **unknown_fields):
         '''
-        params : typing.Sequence<+T_co>[~MachineContainers]<~MachineContainers>
+        params : typing.Sequence[~MachineContainers]
         '''
         self.params = [MachineContainers.from_json(o) for o in params or []]
 
@@ -3833,7 +5284,7 @@ class MachineHardware(Type):
         cpu_power : int
         mem : int
         root_disk : int
-        tags : typing.Sequence<+T_co>[str]
+        tags : typing.Sequence[str]
         '''
         self.arch = arch
         self.availability_zone = availability_zone
@@ -3851,7 +5302,7 @@ class MachineNetworkConfigResult(Type):
     def __init__(self, error=None, info=None, **unknown_fields):
         '''
         error : Error
-        info : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+        info : typing.Sequence[~NetworkConfig]
         '''
         self.error = Error.from_json(error) if error else None
         self.info = [NetworkConfig.from_json(o) for o in info or []]
@@ -3863,7 +5314,7 @@ class MachineNetworkConfigResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~MachineNetworkConfigResult]<~MachineNetworkConfigResult>
+        results : typing.Sequence[~MachineNetworkConfigResult]
         '''
         self.results = [MachineNetworkConfigResult.from_json(o) for o in results or []]
 
@@ -3902,7 +5353,7 @@ class MachinePortsParams(Type):
     _toPy = {'params': 'params'}
     def __init__(self, params=None, **unknown_fields):
         '''
-        params : typing.Sequence<+T_co>[~MachinePorts]<~MachinePorts>
+        params : typing.Sequence[~MachinePorts]
         '''
         self.params = [MachinePorts.from_json(o) for o in params or []]
 
@@ -3914,7 +5365,7 @@ class MachinePortsResult(Type):
     def __init__(self, error=None, ports=None, **unknown_fields):
         '''
         error : Error
-        ports : typing.Sequence<+T_co>[~MachinePortRange]<~MachinePortRange>
+        ports : typing.Sequence[~MachinePortRange]
         '''
         self.error = Error.from_json(error) if error else None
         self.ports = [MachinePortRange.from_json(o) for o in ports or []]
@@ -3926,7 +5377,7 @@ class MachinePortsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~MachinePortsResult]<~MachinePortsResult>
+        results : typing.Sequence[~MachinePortsResult]
         '''
         self.results = [MachinePortsResult.from_json(o) for o in results or []]
 
@@ -3938,15 +5389,15 @@ class MachineStatus(Type):
     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):
         '''
         agent_status : DetailedStatus
-        containers : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
+        containers : typing.Mapping[str, ~MachineStatus]
         dns_name : str
         hardware : str
         has_vote : bool
         id_ : str
         instance_id : str
         instance_status : DetailedStatus
-        ip_addresses : typing.Sequence<+T_co>[str]
-        jobs : typing.Sequence<+T_co>[str]
+        ip_addresses : typing.Sequence[str]
+        jobs : typing.Sequence[str]
         series : str
         wants_vote : bool
         '''
@@ -3983,7 +5434,7 @@ class MachineStorageIds(Type):
     _toPy = {'ids': 'ids'}
     def __init__(self, ids=None, **unknown_fields):
         '''
-        ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
+        ids : typing.Sequence[~MachineStorageId]
         '''
         self.ids = [MachineStorageId.from_json(o) for o in ids or []]
 
@@ -3994,7 +5445,7 @@ class MachineStorageIdsWatchResult(Type):
     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
         '''
-        changes : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
+        changes : typing.Sequence[~MachineStorageId]
         error : Error
         watcher_id : str
         '''
@@ -4009,7 +5460,7 @@ class MachineStorageIdsWatchResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
+        results : typing.Sequence[~MachineStorageIdsWatchResult]
         '''
         self.results = [MachineStorageIdsWatchResult.from_json(o) for o in results or []]
 
@@ -4021,7 +5472,7 @@ class MapResult(Type):
     def __init__(self, error=None, result=None, **unknown_fields):
         '''
         error : Error
-        result : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        result : typing.Mapping[str, typing.Any]
         '''
         self.error = Error.from_json(error) if error else None
         self.result = result
@@ -4033,7 +5484,7 @@ class MapResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~MapResult]<~MapResult>
+        results : typing.Sequence[~MapResult]
         '''
         self.results = [MapResult.from_json(o) for o in results or []]
 
@@ -4068,7 +5519,7 @@ class Member(Type):
         id_ : int
         priority : float
         slavedelay : int
-        tags : typing.Mapping<~KT, +VT_co>[str, str]
+        tags : typing.Mapping[str, str]
         votes : int
         '''
         self.address = address
@@ -4088,7 +5539,7 @@ class MergeLeadershipSettingsBulkParams(Type):
     _toPy = {'params': 'params'}
     def __init__(self, params=None, **unknown_fields):
         '''
-        params : typing.Sequence<+T_co>[~MergeLeadershipSettingsParam]<~MergeLeadershipSettingsParam>
+        params : typing.Sequence[~MergeLeadershipSettingsParam]
         '''
         self.params = [MergeLeadershipSettingsParam.from_json(o) for o in params or []]
 
@@ -4100,7 +5551,7 @@ class MergeLeadershipSettingsParam(Type):
     def __init__(self, application_tag=None, settings=None, **unknown_fields):
         '''
         application_tag : str
-        settings : typing.Mapping<~KT, +VT_co>[str, str]
+        settings : typing.Mapping[str, str]
         '''
         self.application_tag = application_tag
         self.settings = settings
@@ -4112,7 +5563,7 @@ class MetadataImageIds(Type):
     _toPy = {'image-ids': 'image_ids'}
     def __init__(self, image_ids=None, **unknown_fields):
         '''
-        image_ids : typing.Sequence<+T_co>[str]
+        image_ids : typing.Sequence[str]
         '''
         self.image_ids = image_ids
 
@@ -4123,7 +5574,7 @@ class MetadataSaveParams(Type):
     _toPy = {'metadata': 'metadata'}
     def __init__(self, metadata=None, **unknown_fields):
         '''
-        metadata : typing.Sequence<+T_co>[~CloudImageMetadataList]<~CloudImageMetadataList>
+        metadata : typing.Sequence[~CloudImageMetadataList]
         '''
         self.metadata = [CloudImageMetadataList.from_json(o) for o in metadata or []]
 
@@ -4162,7 +5613,7 @@ class MeterStatusParams(Type):
     _toPy = {'statues': 'statues'}
     def __init__(self, statues=None, **unknown_fields):
         '''
-        statues : typing.Sequence<+T_co>[~MeterStatusParam]<~MeterStatusParam>
+        statues : typing.Sequence[~MeterStatusParam]
         '''
         self.statues = [MeterStatusParam.from_json(o) for o in statues or []]
 
@@ -4188,7 +5639,7 @@ class MeterStatusResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~MeterStatusResult]<~MeterStatusResult>
+        results : typing.Sequence[~MeterStatusResult]
         '''
         self.results = [MeterStatusResult.from_json(o) for o in results or []]
 
@@ -4216,7 +5667,7 @@ class MetricBatch(Type):
         '''
         charm_url : str
         created : str
-        metrics : typing.Sequence<+T_co>[~Metric]<~Metric>
+        metrics : typing.Sequence[~Metric]
         uuid : str
         '''
         self.charm_url = charm_url
@@ -4244,7 +5695,7 @@ class MetricBatchParams(Type):
     _toPy = {'batches': 'batches'}
     def __init__(self, batches=None, **unknown_fields):
         '''
-        batches : typing.Sequence<+T_co>[~MetricBatchParam]<~MetricBatchParam>
+        batches : typing.Sequence[~MetricBatchParam]
         '''
         self.batches = [MetricBatchParam.from_json(o) for o in batches or []]
 
@@ -4272,7 +5723,7 @@ class MetricResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~EntityMetrics]<~EntityMetrics>
+        results : typing.Sequence[~EntityMetrics]
         '''
         self.results = [EntityMetrics.from_json(o) for o in results or []]
 
@@ -4321,9 +5772,9 @@ class MigrationStatus(Type):
         external_control : bool
         migration_id : str
         phase : str
-        source_api_addrs : typing.Sequence<+T_co>[str]
+        source_api_addrs : typing.Sequence[str]
         source_ca_cert : str
-        target_api_addrs : typing.Sequence<+T_co>[str]
+        target_api_addrs : typing.Sequence[str]
         target_ca_cert : str
         '''
         self.attempt = attempt
@@ -4342,7 +5793,7 @@ class MigrationTargetInfo(Type):
     _toPy = {'addrs': 'addrs', 'auth-tag': 'auth_tag', 'ca-cert': 'ca_cert', 'controller-tag': 'controller_tag', 'macaroons': 'macaroons', 'password': 'password'}
     def __init__(self, addrs=None, auth_tag=None, ca_cert=None, controller_tag=None, macaroons=None, password=None, **unknown_fields):
         '''
-        addrs : typing.Sequence<+T_co>[str]
+        addrs : typing.Sequence[str]
         auth_tag : str
         ca_cert : str
         controller_tag : str
@@ -4378,12 +5829,12 @@ class MinionReports(Type):
     _toPy = {'failed': 'failed', 'migration-id': 'migration_id', 'phase': 'phase', 'success-count': 'success_count', 'unknown-count': 'unknown_count', 'unknown-sample': 'unknown_sample'}
     def __init__(self, failed=None, migration_id=None, phase=None, success_count=None, unknown_count=None, unknown_sample=None, **unknown_fields):
         '''
-        failed : typing.Sequence<+T_co>[str]
+        failed : typing.Sequence[str]
         migration_id : str
         phase : str
         success_count : int
         unknown_count : int
-        unknown_sample : typing.Sequence<+T_co>[str]
+        unknown_sample : typing.Sequence[str]
         '''
         self.failed = failed
         self.migration_id = migration_id
@@ -4409,6 +5860,19 @@ class Model(Type):
 
 
 
+class ModelAccess(Type):
+    _toSchema = {'access': 'access', 'model': 'model'}
+    _toPy = {'access': 'access', 'model': 'model'}
+    def __init__(self, access=None, model=None, **unknown_fields):
+        '''
+        access : str
+        model : str
+        '''
+        self.access = access
+        self.model = model
+
+
+
 class ModelArgs(Type):
     _toSchema = {'model_tag': 'model-tag'}
     _toPy = {'model-tag': 'model_tag'}
@@ -4425,7 +5889,7 @@ class ModelBlockInfo(Type):
     _toPy = {'blocks': 'blocks', 'model-uuid': 'model_uuid', 'name': 'name', 'owner-tag': 'owner_tag'}
     def __init__(self, blocks=None, model_uuid=None, name=None, owner_tag=None, **unknown_fields):
         '''
-        blocks : typing.Sequence<+T_co>[str]
+        blocks : typing.Sequence[str]
         model_uuid : str
         name : str
         owner_tag : str
@@ -4442,7 +5906,7 @@ class ModelBlockInfoList(Type):
     _toPy = {'models': 'models'}
     def __init__(self, models=None, **unknown_fields):
         '''
-        models : typing.Sequence<+T_co>[~ModelBlockInfo]<~ModelBlockInfo>
+        models : typing.Sequence[~ModelBlockInfo]
         '''
         self.models = [ModelBlockInfo.from_json(o) for o in models or []]
 
@@ -4453,7 +5917,7 @@ class ModelConfigResult(Type):
     _toPy = {'config': 'config'}
     def __init__(self, config=None, **unknown_fields):
         '''
-        config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        config : typing.Mapping[str, typing.Any]
         '''
         self.config = config
 
@@ -4464,7 +5928,7 @@ class ModelConfigResults(Type):
     _toPy = {'config': 'config'}
     def __init__(self, config=None, **unknown_fields):
         '''
-        config : typing.Mapping<~KT, +VT_co>[str, ~ConfigValue]<~ConfigValue>
+        config : typing.Mapping[str, ~ConfigValue]
         '''
         self.config = config
 
@@ -4476,7 +5940,7 @@ class ModelCreateArgs(Type):
     def __init__(self, cloud_tag=None, config=None, credential=None, name=None, owner_tag=None, region=None, **unknown_fields):
         '''
         cloud_tag : str
-        config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        config : typing.Mapping[str, typing.Any]
         credential : str
         name : str
         owner_tag : str
@@ -4491,6 +5955,23 @@ class ModelCreateArgs(Type):
 
 
 
+class ModelCredential(Type):
+    _toSchema = {'credential_tag': 'credential-tag', 'exists': 'exists', 'model_tag': 'model-tag', 'valid': 'valid'}
+    _toPy = {'credential-tag': 'credential_tag', 'exists': 'exists', 'model-tag': 'model_tag', 'valid': 'valid'}
+    def __init__(self, credential_tag=None, exists=None, model_tag=None, valid=None, **unknown_fields):
+        '''
+        credential_tag : str
+        exists : bool
+        model_tag : str
+        valid : bool
+        '''
+        self.credential_tag = credential_tag
+        self.exists = exists
+        self.model_tag = model_tag
+        self.valid = valid
+
+
+
 class ModelDefaultValues(Type):
     _toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'config': 'config'}
     _toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'config': 'config'}
@@ -4498,7 +5979,7 @@ class ModelDefaultValues(Type):
         '''
         cloud_region : str
         cloud_tag : str
-        config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        config : typing.Mapping[str, typing.Any]
         '''
         self.cloud_region = cloud_region
         self.cloud_tag = cloud_tag
@@ -4511,9 +5992,9 @@ class ModelDefaults(Type):
     _toPy = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
     def __init__(self, controller=None, default=None, regions=None, **unknown_fields):
         '''
-        controller : typing.Mapping<~KT, +VT_co>[str, typing.Any]
-        default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
-        regions : typing.Sequence<+T_co>[~RegionDefaults]<~RegionDefaults>
+        controller : typing.Mapping[str, typing.Any]
+        default : typing.Mapping[str, typing.Any]
+        regions : typing.Sequence[~RegionDefaults]
         '''
         self.controller = controller
         self.default = default
@@ -4526,16 +6007,48 @@ class ModelDefaultsResult(Type):
     _toPy = {'config': 'config'}
     def __init__(self, config=None, **unknown_fields):
         '''
-        config : typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
+        config : typing.Mapping[str, ~ModelDefaults]
         '''
         self.config = config
 
 
 
+class ModelEntityCount(Type):
+    _toSchema = {'count': 'count', 'entity': 'entity'}
+    _toPy = {'count': 'count', 'entity': 'entity'}
+    def __init__(self, count=None, entity=None, **unknown_fields):
+        '''
+        count : int
+        entity : str
+        '''
+        self.count = count
+        self.entity = entity
+
+
+
+class ModelFilesystemInfo(Type):
+    _toSchema = {'detachable': 'detachable', 'id_': 'id', 'message': 'message', 'provider_id': 'provider-id', 'status': 'status'}
+    _toPy = {'detachable': 'detachable', 'id': 'id_', 'message': 'message', 'provider-id': 'provider_id', 'status': 'status'}
+    def __init__(self, detachable=None, id_=None, message=None, provider_id=None, status=None, **unknown_fields):
+        '''
+        detachable : bool
+        id_ : str
+        message : str
+        provider_id : str
+        status : str
+        '''
+        self.detachable = detachable
+        self.id_ = id_
+        self.message = message
+        self.provider_id = provider_id
+        self.status = status
+
+
+
 class ModelInfo(Type):
-    _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'}
-    _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'}
-    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):
+    _toSchema = {'agent_version': 'agent-version', 'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'default_series': 'default-series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'sla': 'sla', 'status': 'status', 'type_': 'type', 'users': 'users', 'uuid': 'uuid'}
+    _toPy = {'agent-version': 'agent_version', 'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'default-series': 'default_series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'sla': 'sla', 'status': 'status', 'type': 'type_', 'users': 'users', 'uuid': 'uuid'}
+    def __init__(self, agent_version=None, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, default_series=None, life=None, machines=None, migration=None, name=None, owner_tag=None, provider_type=None, sla=None, status=None, type_=None, users=None, uuid=None, **unknown_fields):
         '''
         agent_version : Number
         cloud_credential_tag : str
@@ -4544,14 +6057,15 @@ class ModelInfo(Type):
         controller_uuid : str
         default_series : str
         life : str
-        machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
+        machines : typing.Sequence[~ModelMachineInfo]
         migration : ModelMigrationStatus
         name : str
         owner_tag : str
         provider_type : str
         sla : ModelSLAInfo
         status : EntityStatus
-        users : typing.Sequence<+T_co>[~ModelUserInfo]<~ModelUserInfo>
+        type_ : str
+        users : typing.Sequence[~ModelUserInfo]
         uuid : str
         '''
         self.agent_version = Number.from_json(agent_version) if agent_version else None
@@ -4568,6 +6082,7 @@ class ModelInfo(Type):
         self.provider_type = provider_type
         self.sla = ModelSLAInfo.from_json(sla) if sla else None
         self.status = EntityStatus.from_json(status) if status else None
+        self.type_ = type_
         self.users = [ModelUserInfo.from_json(o) for o in users or []]
         self.uuid = uuid
 
@@ -4591,7 +6106,7 @@ class ModelInfoResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ModelInfoResult]<~ModelInfoResult>
+        results : typing.Sequence[~ModelInfoResult]
         '''
         self.results = [ModelInfoResult.from_json(o) for o in results or []]
 
@@ -4613,7 +6128,7 @@ class ModelInstanceTypesConstraints(Type):
     _toPy = {'constraints': 'constraints'}
     def __init__(self, constraints=None, **unknown_fields):
         '''
-        constraints : typing.Sequence<+T_co>[~ModelInstanceTypesConstraint]<~ModelInstanceTypesConstraint>
+        constraints : typing.Sequence[~ModelInstanceTypesConstraint]
         '''
         self.constraints = [ModelInstanceTypesConstraint.from_json(o) for o in constraints or []]
 
@@ -4675,7 +6190,7 @@ class ModelSLA(Type):
     _toPy = {'creds': 'creds', 'level': 'level'}
     def __init__(self, creds=None, level=None, **unknown_fields):
         '''
-        creds : typing.Sequence<+T_co>[int]
+        creds : typing.Sequence[int]
         level : str
         '''
         self.creds = creds
@@ -4696,12 +6211,23 @@ class ModelSLAInfo(Type):
 
 
 
+class ModelSequencesResult(Type):
+    _toSchema = {'sequences': 'sequences'}
+    _toPy = {'sequences': 'sequences'}
+    def __init__(self, sequences=None, **unknown_fields):
+        '''
+        sequences : typing.Mapping[str, int]
+        '''
+        self.sequences = sequences
+
+
+
 class ModelSet(Type):
     _toSchema = {'config': 'config'}
     _toPy = {'config': 'config'}
     def __init__(self, config=None, **unknown_fields):
         '''
-        config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        config : typing.Mapping[str, typing.Any]
         '''
         self.config = config
 
@@ -4715,7 +6241,7 @@ class ModelStatus(Type):
         application_count : int
         hosted_machine_count : int
         life : str
-        machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
+        machines : typing.Sequence[~ModelMachineInfo]
         model_tag : str
         owner_tag : str
         '''
@@ -4729,9 +6255,9 @@ class ModelStatus(Type):
 
 
 class ModelStatusInfo(Type):
-    _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'}
-    _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'}
-    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):
+    _toSchema = {'available_version': 'available-version', 'cloud_tag': 'cloud-tag', 'meter_status': 'meter-status', 'model_status': 'model-status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'type_': 'type', 'version': 'version'}
+    _toPy = {'available-version': 'available_version', 'cloud-tag': 'cloud_tag', 'meter-status': 'meter_status', 'model-status': 'model_status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'type': 'type_', 'version': 'version'}
+    def __init__(self, available_version=None, cloud_tag=None, meter_status=None, model_status=None, name=None, region=None, sla=None, type_=None, version=None, **unknown_fields):
         '''
         available_version : str
         cloud_tag : str
@@ -4740,6 +6266,7 @@ class ModelStatusInfo(Type):
         name : str
         region : str
         sla : str
+        type_ : str
         version : str
         '''
         self.available_version = available_version
@@ -4749,6 +6276,7 @@ class ModelStatusInfo(Type):
         self.name = name
         self.region = region
         self.sla = sla
+        self.type_ = type_
         self.version = version
 
 
@@ -4758,12 +6286,94 @@ class ModelStatusResults(Type):
     _toPy = {'models': 'models'}
     def __init__(self, models=None, **unknown_fields):
         '''
-        models : typing.Sequence<+T_co>[~ModelStatus]<~ModelStatus>
+        models : typing.Sequence[~ModelStatus]
         '''
         self.models = [ModelStatus.from_json(o) for o in models or []]
 
 
 
+class ModelSummariesRequest(Type):
+    _toSchema = {'all_': 'all', 'user_tag': 'user-tag'}
+    _toPy = {'all': 'all_', 'user-tag': 'user_tag'}
+    def __init__(self, all_=None, user_tag=None, **unknown_fields):
+        '''
+        all_ : bool
+        user_tag : str
+        '''
+        self.all_ = all_
+        self.user_tag = user_tag
+
+
+
+class ModelSummary(Type):
+    _toSchema = {'agent_version': 'agent-version', 'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'counts': 'counts', 'default_series': 'default-series', 'last_connection': 'last-connection', 'life': 'life', 'migration': 'migration', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'sla': 'sla', 'status': 'status', 'type_': 'type', 'user_access': 'user-access', 'uuid': 'uuid'}
+    _toPy = {'agent-version': 'agent_version', 'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'counts': 'counts', 'default-series': 'default_series', 'last-connection': 'last_connection', 'life': 'life', 'migration': 'migration', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'sla': 'sla', 'status': 'status', 'type': 'type_', 'user-access': 'user_access', 'uuid': 'uuid'}
+    def __init__(self, agent_version=None, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, counts=None, default_series=None, last_connection=None, life=None, migration=None, name=None, owner_tag=None, provider_type=None, sla=None, status=None, type_=None, user_access=None, uuid=None, **unknown_fields):
+        '''
+        agent_version : Number
+        cloud_credential_tag : str
+        cloud_region : str
+        cloud_tag : str
+        controller_uuid : str
+        counts : typing.Sequence[~ModelEntityCount]
+        default_series : str
+        last_connection : str
+        life : str
+        migration : ModelMigrationStatus
+        name : str
+        owner_tag : str
+        provider_type : str
+        sla : ModelSLAInfo
+        status : EntityStatus
+        type_ : str
+        user_access : str
+        uuid : str
+        '''
+        self.agent_version = Number.from_json(agent_version) if agent_version else None
+        self.cloud_credential_tag = cloud_credential_tag
+        self.cloud_region = cloud_region
+        self.cloud_tag = cloud_tag
+        self.controller_uuid = controller_uuid
+        self.counts = [ModelEntityCount.from_json(o) for o in counts or []]
+        self.default_series = default_series
+        self.last_connection = last_connection
+        self.life = life
+        self.migration = ModelMigrationStatus.from_json(migration) if migration else None
+        self.name = name
+        self.owner_tag = owner_tag
+        self.provider_type = provider_type
+        self.sla = ModelSLAInfo.from_json(sla) if sla else None
+        self.status = EntityStatus.from_json(status) if status else None
+        self.type_ = type_
+        self.user_access = user_access
+        self.uuid = uuid
+
+
+
+class ModelSummaryResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : ModelSummary
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = ModelSummary.from_json(result) if result else None
+
+
+
+class ModelSummaryResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ModelSummaryResult]
+        '''
+        self.results = [ModelSummaryResult.from_json(o) for o in results or []]
+
+
+
 class ModelTag(Type):
     _toSchema = {}
     _toPy = {}
@@ -4780,7 +6390,7 @@ class ModelUnset(Type):
     _toPy = {'keys': 'keys'}
     def __init__(self, keys=None, **unknown_fields):
         '''
-        keys : typing.Sequence<+T_co>[str]
+        keys : typing.Sequence[str]
         '''
         self.keys = keys
 
@@ -4793,7 +6403,7 @@ class ModelUnsetKeys(Type):
         '''
         cloud_region : str
         cloud_tag : str
-        keys : typing.Sequence<+T_co>[str]
+        keys : typing.Sequence[str]
         '''
         self.cloud_region = cloud_region
         self.cloud_tag = cloud_tag
@@ -4836,12 +6446,59 @@ class ModelUserInfoResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ModelUserInfoResult]<~ModelUserInfoResult>
+        results : typing.Sequence[~ModelUserInfoResult]
         '''
         self.results = [ModelUserInfoResult.from_json(o) for o in results or []]
 
 
 
+class ModelVolumeInfo(Type):
+    _toSchema = {'detachable': 'detachable', 'id_': 'id', 'message': 'message', 'provider_id': 'provider-id', 'status': 'status'}
+    _toPy = {'detachable': 'detachable', 'id': 'id_', 'message': 'message', 'provider-id': 'provider_id', 'status': 'status'}
+    def __init__(self, detachable=None, id_=None, message=None, provider_id=None, status=None, **unknown_fields):
+        '''
+        detachable : bool
+        id_ : str
+        message : str
+        provider_id : str
+        status : str
+        '''
+        self.detachable = detachable
+        self.id_ = id_
+        self.message = message
+        self.provider_id = provider_id
+        self.status = status
+
+
+
+class ModifyCloudAccess(Type):
+    _toSchema = {'access': 'access', 'action': 'action', 'cloud_tag': 'cloud-tag', 'user_tag': 'user-tag'}
+    _toPy = {'access': 'access', 'action': 'action', 'cloud-tag': 'cloud_tag', 'user-tag': 'user_tag'}
+    def __init__(self, access=None, action=None, cloud_tag=None, user_tag=None, **unknown_fields):
+        '''
+        access : str
+        action : str
+        cloud_tag : str
+        user_tag : str
+        '''
+        self.access = access
+        self.action = action
+        self.cloud_tag = cloud_tag
+        self.user_tag = user_tag
+
+
+
+class ModifyCloudAccessRequest(Type):
+    _toSchema = {'changes': 'changes'}
+    _toPy = {'changes': 'changes'}
+    def __init__(self, changes=None, **unknown_fields):
+        '''
+        changes : typing.Sequence[~ModifyCloudAccess]
+        '''
+        self.changes = [ModifyCloudAccess.from_json(o) for o in changes or []]
+
+
+
 class ModifyControllerAccess(Type):
     _toSchema = {'access': 'access', 'action': 'action', 'user_tag': 'user-tag'}
     _toPy = {'access': 'access', 'action': 'action', 'user-tag': 'user_tag'}
@@ -4862,7 +6519,7 @@ class ModifyControllerAccessRequest(Type):
     _toPy = {'changes': 'changes'}
     def __init__(self, changes=None, **unknown_fields):
         '''
-        changes : typing.Sequence<+T_co>[~ModifyControllerAccess]<~ModifyControllerAccess>
+        changes : typing.Sequence[~ModifyControllerAccess]
         '''
         self.changes = [ModifyControllerAccess.from_json(o) for o in changes or []]
 
@@ -4890,18 +6547,46 @@ class ModifyModelAccessRequest(Type):
     _toPy = {'changes': 'changes'}
     def __init__(self, changes=None, **unknown_fields):
         '''
-        changes : typing.Sequence<+T_co>[~ModifyModelAccess]<~ModifyModelAccess>
+        changes : typing.Sequence[~ModifyModelAccess]
         '''
         self.changes = [ModifyModelAccess.from_json(o) for o in changes or []]
 
 
 
+class ModifyOfferAccess(Type):
+    _toSchema = {'access': 'access', 'action': 'action', 'offer_url': 'offer-url', 'user_tag': 'user-tag'}
+    _toPy = {'access': 'access', 'action': 'action', 'offer-url': 'offer_url', 'user-tag': 'user_tag'}
+    def __init__(self, access=None, action=None, offer_url=None, user_tag=None, **unknown_fields):
+        '''
+        access : str
+        action : str
+        offer_url : str
+        user_tag : str
+        '''
+        self.access = access
+        self.action = action
+        self.offer_url = offer_url
+        self.user_tag = user_tag
+
+
+
+class ModifyOfferAccessRequest(Type):
+    _toSchema = {'changes': 'changes'}
+    _toPy = {'changes': 'changes'}
+    def __init__(self, changes=None, **unknown_fields):
+        '''
+        changes : typing.Sequence[~ModifyOfferAccess]
+        '''
+        self.changes = [ModifyOfferAccess.from_json(o) for o in changes or []]
+
+
+
 class ModifyUserSSHKeys(Type):
     _toSchema = {'ssh_keys': 'ssh-keys', 'user': 'user'}
     _toPy = {'ssh-keys': 'ssh_keys', 'user': 'user'}
     def __init__(self, ssh_keys=None, user=None, **unknown_fields):
         '''
-        ssh_keys : typing.Sequence<+T_co>[str]
+        ssh_keys : typing.Sequence[str]
         user : str
         '''
         self.ssh_keys = ssh_keys
@@ -4914,9 +6599,9 @@ class MongoUpgradeResults(Type):
     _toPy = {'ha-members': 'ha_members', 'master': 'master', 'rs-members': 'rs_members'}
     def __init__(self, ha_members=None, master=None, rs_members=None, **unknown_fields):
         '''
-        ha_members : typing.Sequence<+T_co>[~HAMember]<~HAMember>
+        ha_members : typing.Sequence[~HAMember]
         master : HAMember
-        rs_members : typing.Sequence<+T_co>[~Member]<~Member>
+        rs_members : typing.Sequence[~Member]
         '''
         self.ha_members = [HAMember.from_json(o) for o in ha_members or []]
         self.master = HAMember.from_json(master) if master else None
@@ -4951,8 +6636,8 @@ class NetworkConfig(Type):
         config_type : str
         device_index : int
         disabled : bool
-        dns_search_domains : typing.Sequence<+T_co>[str]
-        dns_servers : typing.Sequence<+T_co>[str]
+        dns_search_domains : typing.Sequence[str]
+        dns_servers : typing.Sequence[str]
         gateway_address : str
         interface_name : str
         interface_type : str
@@ -4995,7 +6680,7 @@ class NetworkInfo(Type):
     _toPy = {'addresses': 'addresses', 'interface-name': 'interface_name', 'mac-address': 'mac_address'}
     def __init__(self, addresses=None, interface_name=None, mac_address=None, **unknown_fields):
         '''
-        addresses : typing.Sequence<+T_co>[~InterfaceAddress]<~InterfaceAddress>
+        addresses : typing.Sequence[~InterfaceAddress]
         interface_name : str
         mac_address : str
         '''
@@ -5010,7 +6695,7 @@ class NetworkInfoParams(Type):
     _toPy = {'bindings': 'bindings', 'unit': 'unit'}
     def __init__(self, bindings=None, unit=None, **unknown_fields):
         '''
-        bindings : typing.Sequence<+T_co>[str]
+        bindings : typing.Sequence[str]
         unit : str
         '''
         self.bindings = bindings
@@ -5024,7 +6709,7 @@ class NetworkInfoResult(Type):
     def __init__(self, error=None, network_info=None, **unknown_fields):
         '''
         error : Error
-        network_info : typing.Sequence<+T_co>[~NetworkInfo]<~NetworkInfo>
+        network_info : typing.Sequence[~NetworkInfo]
         '''
         self.error = Error.from_json(error) if error else None
         self.network_info = [NetworkInfo.from_json(o) for o in network_info or []]
@@ -5036,7 +6721,7 @@ class NetworkInfoResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Mapping<~KT, +VT_co>[str, ~NetworkInfoResult]<~NetworkInfoResult>
+        results : typing.Mapping[str, ~NetworkInfoResult]
         '''
         self.results = results
 
@@ -5047,9 +6732,9 @@ class NetworkInterface(Type):
     _toPy = {'dns-nameservers': 'dns_nameservers', 'gateway': 'gateway', 'ip-addresses': 'ip_addresses', 'is-up': 'is_up', 'mac-address': 'mac_address', 'space': 'space'}
     def __init__(self, dns_nameservers=None, gateway=None, ip_addresses=None, is_up=None, mac_address=None, space=None, **unknown_fields):
         '''
-        dns_nameservers : typing.Sequence<+T_co>[str]
+        dns_nameservers : typing.Sequence[str]
         gateway : str
-        ip_addresses : typing.Sequence<+T_co>[str]
+        ip_addresses : typing.Sequence[str]
         is_up : bool
         mac_address : str
         space : str
@@ -5096,7 +6781,7 @@ class NotifyWatchResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
+        results : typing.Sequence[~NotifyWatchResult]
         '''
         self.results = [NotifyWatchResult.from_json(o) for o in results or []]
 
@@ -5121,6 +6806,173 @@ class Number(Type):
 
 
 
+class OfferArg(Type):
+    _toSchema = {'macaroons': 'macaroons', 'offer_uuid': 'offer-uuid'}
+    _toPy = {'macaroons': 'macaroons', 'offer-uuid': 'offer_uuid'}
+    def __init__(self, macaroons=None, offer_uuid=None, **unknown_fields):
+        '''
+        macaroons : typing.Sequence[~Macaroon]
+        offer_uuid : str
+        '''
+        self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+        self.offer_uuid = offer_uuid
+
+
+
+class OfferArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~OfferArg]
+        '''
+        self.args = [OfferArg.from_json(o) for o in args or []]
+
+
+
+class OfferConnection(Type):
+    _toSchema = {'endpoint': 'endpoint', 'ingress_subnets': 'ingress-subnets', 'relation_id': 'relation-id', 'source_model_tag': 'source-model-tag', 'status': 'status', 'username': 'username'}
+    _toPy = {'endpoint': 'endpoint', 'ingress-subnets': 'ingress_subnets', 'relation-id': 'relation_id', 'source-model-tag': 'source_model_tag', 'status': 'status', 'username': 'username'}
+    def __init__(self, endpoint=None, ingress_subnets=None, relation_id=None, source_model_tag=None, status=None, username=None, **unknown_fields):
+        '''
+        endpoint : str
+        ingress_subnets : typing.Sequence[str]
+        relation_id : int
+        source_model_tag : str
+        status : EntityStatus
+        username : str
+        '''
+        self.endpoint = endpoint
+        self.ingress_subnets = ingress_subnets
+        self.relation_id = relation_id
+        self.source_model_tag = source_model_tag
+        self.status = EntityStatus.from_json(status) if status else None
+        self.username = username
+
+
+
+class OfferFilter(Type):
+    _toSchema = {'allowed_users': 'allowed-users', 'application_description': 'application-description', 'application_name': 'application-name', 'application_user': 'application-user', 'connected_users': 'connected-users', 'endpoints': 'endpoints', 'model_name': 'model-name', 'offer_name': 'offer-name', 'owner_name': 'owner-name'}
+    _toPy = {'allowed-users': 'allowed_users', 'application-description': 'application_description', 'application-name': 'application_name', 'application-user': 'application_user', 'connected-users': 'connected_users', 'endpoints': 'endpoints', 'model-name': 'model_name', 'offer-name': 'offer_name', 'owner-name': 'owner_name'}
+    def __init__(self, allowed_users=None, application_description=None, application_name=None, application_user=None, connected_users=None, endpoints=None, model_name=None, offer_name=None, owner_name=None, **unknown_fields):
+        '''
+        allowed_users : typing.Sequence[str]
+        application_description : str
+        application_name : str
+        application_user : str
+        connected_users : typing.Sequence[str]
+        endpoints : typing.Sequence[~EndpointFilterAttributes]
+        model_name : str
+        offer_name : str
+        owner_name : str
+        '''
+        self.allowed_users = allowed_users
+        self.application_description = application_description
+        self.application_name = application_name
+        self.application_user = application_user
+        self.connected_users = connected_users
+        self.endpoints = [EndpointFilterAttributes.from_json(o) for o in endpoints or []]
+        self.model_name = model_name
+        self.offer_name = offer_name
+        self.owner_name = owner_name
+
+
+
+class OfferFilters(Type):
+    _toSchema = {'filters': 'Filters'}
+    _toPy = {'Filters': 'filters'}
+    def __init__(self, filters=None, **unknown_fields):
+        '''
+        filters : typing.Sequence[~OfferFilter]
+        '''
+        self.filters = [OfferFilter.from_json(o) for o in filters or []]
+
+
+
+class OfferStatusChange(Type):
+    _toSchema = {'offer_name': 'offer-name', 'status': 'status'}
+    _toPy = {'offer-name': 'offer_name', 'status': 'status'}
+    def __init__(self, offer_name=None, status=None, **unknown_fields):
+        '''
+        offer_name : str
+        status : EntityStatus
+        '''
+        self.offer_name = offer_name
+        self.status = EntityStatus.from_json(status) if status else None
+
+
+
+class OfferStatusWatchResult(Type):
+    _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+    _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
+    def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
+        '''
+        changes : typing.Sequence[~OfferStatusChange]
+        error : Error
+        watcher_id : str
+        '''
+        self.changes = [OfferStatusChange.from_json(o) for o in changes or []]
+        self.error = Error.from_json(error) if error else None
+        self.watcher_id = watcher_id
+
+
+
+class OfferStatusWatchResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~OfferStatusWatchResult]
+        '''
+        self.results = [OfferStatusWatchResult.from_json(o) for o in results or []]
+
+
+
+class OfferURLs(Type):
+    _toSchema = {'offer_urls': 'offer-urls'}
+    _toPy = {'offer-urls': 'offer_urls'}
+    def __init__(self, offer_urls=None, **unknown_fields):
+        '''
+        offer_urls : typing.Sequence[str]
+        '''
+        self.offer_urls = offer_urls
+
+
+
+class OfferUserDetails(Type):
+    _toSchema = {'access': 'access', 'display_name': 'display-name', 'user': 'user'}
+    _toPy = {'access': 'access', 'display-name': 'display_name', 'user': 'user'}
+    def __init__(self, access=None, display_name=None, user=None, **unknown_fields):
+        '''
+        access : str
+        display_name : str
+        user : str
+        '''
+        self.access = access
+        self.display_name = display_name
+        self.user = user
+
+
+
+class OperatorProvisioningInfo(Type):
+    _toSchema = {'api_addresses': 'api-addresses', 'charm_storage': 'charm-storage', 'image_path': 'image-path', 'tags': 'tags', 'version': 'version'}
+    _toPy = {'api-addresses': 'api_addresses', 'charm-storage': 'charm_storage', 'image-path': 'image_path', 'tags': 'tags', 'version': 'version'}
+    def __init__(self, api_addresses=None, charm_storage=None, image_path=None, tags=None, version=None, **unknown_fields):
+        '''
+        api_addresses : typing.Sequence[str]
+        charm_storage : KubernetesFilesystemParams
+        image_path : str
+        tags : typing.Mapping[str, str]
+        version : Number
+        '''
+        self.api_addresses = api_addresses
+        self.charm_storage = KubernetesFilesystemParams.from_json(charm_storage) if charm_storage else None
+        self.image_path = image_path
+        self.tags = tags
+        self.version = Number.from_json(version) if version else None
+
+
+
 class Payload(Type):
     _toSchema = {'class_': 'class', 'id_': 'id', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type_': 'type', 'unit': 'unit'}
     _toPy = {'class': 'class_', 'id': 'id_', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type': 'type_', 'unit': 'unit'}
@@ -5128,7 +6980,7 @@ class Payload(Type):
         '''
         class_ : str
         id_ : str
-        labels : typing.Sequence<+T_co>[str]
+        labels : typing.Sequence[str]
         machine : str
         status : str
         type_ : str
@@ -5149,7 +7001,7 @@ class PayloadListArgs(Type):
     _toPy = {'patterns': 'patterns'}
     def __init__(self, patterns=None, **unknown_fields):
         '''
-        patterns : typing.Sequence<+T_co>[str]
+        patterns : typing.Sequence[str]
         '''
         self.patterns = patterns
 
@@ -5160,7 +7012,7 @@ class PayloadListResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~Payload]<~Payload>
+        results : typing.Sequence[~Payload]
         '''
         self.results = [Payload.from_json(o) for o in results or []]
 
@@ -5188,7 +7040,7 @@ class PayloadResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~PayloadResult]<~PayloadResult>
+        results : typing.Sequence[~PayloadResult]
         '''
         self.results = [PayloadResult.from_json(o) for o in results or []]
 
@@ -5212,12 +7064,47 @@ class PhaseResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~PhaseResult]<~PhaseResult>
+        results : typing.Sequence[~PhaseResult]
         '''
         self.results = [PhaseResult.from_json(o) for o in results or []]
 
 
 
+class PinApplicationResult(Type):
+    _toSchema = {'application_name': 'application-name', 'error': 'error'}
+    _toPy = {'application-name': 'application_name', 'error': 'error'}
+    def __init__(self, application_name=None, error=None, **unknown_fields):
+        '''
+        application_name : str
+        error : Error
+        '''
+        self.application_name = application_name
+        self.error = Error.from_json(error) if error else None
+
+
+
+class PinApplicationsResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~PinApplicationResult]
+        '''
+        self.results = [PinApplicationResult.from_json(o) for o in results or []]
+
+
+
+class PinnedLeadershipResult(Type):
+    _toSchema = {'result': 'result'}
+    _toPy = {'result': 'result'}
+    def __init__(self, result=None, **unknown_fields):
+        '''
+        result : typing.Sequence[str]
+        '''
+        self.result = result
+
+
+
 class Placement(Type):
     _toSchema = {'directive': 'directive', 'scope': 'scope'}
     _toPy = {'directive': 'directive', 'scope': 'scope'}
@@ -5268,6 +7155,36 @@ class PrivateAddressResults(Type):
 
 
 
+class ProfileChangeResult(Type):
+    _toSchema = {'error': 'error', 'new_profile_name': 'new-profile-name', 'old_profile_name': 'old-profile-name', 'profile': 'profile', 'subordinate': 'subordinate'}
+    _toPy = {'error': 'error', 'new-profile-name': 'new_profile_name', 'old-profile-name': 'old_profile_name', 'profile': 'profile', 'subordinate': 'subordinate'}
+    def __init__(self, error=None, new_profile_name=None, old_profile_name=None, profile=None, subordinate=None, **unknown_fields):
+        '''
+        error : Error
+        new_profile_name : str
+        old_profile_name : str
+        profile : CharmLXDProfile
+        subordinate : bool
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.new_profile_name = new_profile_name
+        self.old_profile_name = old_profile_name
+        self.profile = CharmLXDProfile.from_json(profile) if profile else None
+        self.subordinate = subordinate
+
+
+
+class ProfileChangeResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ProfileChangeResult]
+        '''
+        self.results = [ProfileChangeResult.from_json(o) for o in results or []]
+
+
+
 class ProviderInterfaceInfo(Type):
     _toSchema = {'interface_name': 'interface-name', 'mac_address': 'mac-address', 'provider_id': 'provider-id'}
     _toPy = {'interface-name': 'interface_name', 'mac-address': 'mac_address', 'provider-id': 'provider_id'}
@@ -5289,7 +7206,7 @@ class ProviderInterfaceInfoResult(Type):
     def __init__(self, error=None, interfaces=None, machine_tag=None, **unknown_fields):
         '''
         error : Error
-        interfaces : typing.Sequence<+T_co>[~ProviderInterfaceInfo]<~ProviderInterfaceInfo>
+        interfaces : typing.Sequence[~ProviderInterfaceInfo]
         machine_tag : str
         '''
         self.error = Error.from_json(error) if error else None
@@ -5303,7 +7220,7 @@ class ProviderInterfaceInfoResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ProviderInterfaceInfoResult]<~ProviderInterfaceInfoResult>
+        results : typing.Sequence[~ProviderInterfaceInfoResult]
         '''
         self.results = [ProviderInterfaceInfoResult.from_json(o) for o in results or []]
 
@@ -5317,7 +7234,7 @@ class ProviderSpace(Type):
         error : Error
         name : str
         provider_id : str
-        subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+        subnets : typing.Sequence[~Subnet]
         '''
         self.error = Error.from_json(error) if error else None
         self.name = name
@@ -5332,15 +7249,15 @@ class ProvisioningInfo(Type):
     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):
         '''
         constraints : Value
-        controller_config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
-        endpoint_bindings : typing.Mapping<~KT, +VT_co>[str, str]
-        image_metadata : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
-        jobs : typing.Sequence<+T_co>[str]
+        controller_config : typing.Mapping[str, typing.Any]
+        endpoint_bindings : typing.Mapping[str, str]
+        image_metadata : typing.Sequence[~CloudImageMetadata]
+        jobs : typing.Sequence[str]
         placement : str
         series : str
-        subnets_to_zones : typing.Sequence<+T_co>[str]
-        tags : typing.Mapping<~KT, +VT_co>[str, str]
-        volumes : typing.Sequence<+T_co>[~VolumeParams]<~VolumeParams>
+        subnets_to_zones : typing.Sequence[str]
+        tags : typing.Mapping[str, str]
+        volumes : typing.Sequence[~VolumeParams]
         '''
         self.constraints = Value.from_json(constraints) if constraints else None
         self.controller_config = controller_config
@@ -5373,7 +7290,7 @@ class ProvisioningInfoResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ProvisioningInfoResult]<~ProvisioningInfoResult>
+        results : typing.Sequence[~ProvisioningInfoResult]
         '''
         self.results = [ProvisioningInfoResult.from_json(o) for o in results or []]
 
@@ -5444,7 +7361,7 @@ class ProxyConfigResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ProxyConfigResult]<~ProxyConfigResult>
+        results : typing.Sequence[~ProxyConfigResult]
         '''
         self.results = [ProxyConfigResult.from_json(o) for o in results or []]
 
@@ -5472,6 +7389,17 @@ class PublicAddressResults(Type):
 
 
 
+class QueryApplicationOffersResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ApplicationOfferAdminDetails]
+        '''
+        self.results = [ApplicationOfferAdminDetails.from_json(o) for o in results or []]
+
+
+
 class RebootActionResult(Type):
     _toSchema = {'error': 'error', 'result': 'result'}
     _toPy = {'error': 'error', 'result': 'result'}
@@ -5490,7 +7418,7 @@ class RebootActionResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~RebootActionResult]<~RebootActionResult>
+        results : typing.Sequence[~RebootActionResult]
         '''
         self.results = [RebootActionResult.from_json(o) for o in results or []]
 
@@ -5502,20 +7430,80 @@ class RegionDefaults(Type):
     def __init__(self, region_name=None, value=None, **unknown_fields):
         '''
         region_name : str
-        value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        value : typing.Mapping[str, typing.Any]
         '''
         self.region_name = region_name
         self.value = value
 
 
 
+class RegisterRemoteRelationArg(Type):
+    _toSchema = {'application_token': 'application-token', 'local_endpoint_name': 'local-endpoint-name', 'macaroons': 'macaroons', 'offer_uuid': 'offer-uuid', 'relation_token': 'relation-token', 'remote_endpoint': 'remote-endpoint', 'remote_space': 'remote-space', 'source_model_tag': 'source-model-tag'}
+    _toPy = {'application-token': 'application_token', 'local-endpoint-name': 'local_endpoint_name', 'macaroons': 'macaroons', 'offer-uuid': 'offer_uuid', 'relation-token': 'relation_token', 'remote-endpoint': 'remote_endpoint', 'remote-space': 'remote_space', 'source-model-tag': 'source_model_tag'}
+    def __init__(self, application_token=None, local_endpoint_name=None, macaroons=None, offer_uuid=None, relation_token=None, remote_endpoint=None, remote_space=None, source_model_tag=None, **unknown_fields):
+        '''
+        application_token : str
+        local_endpoint_name : str
+        macaroons : typing.Sequence[~Macaroon]
+        offer_uuid : str
+        relation_token : str
+        remote_endpoint : RemoteEndpoint
+        remote_space : RemoteSpace
+        source_model_tag : str
+        '''
+        self.application_token = application_token
+        self.local_endpoint_name = local_endpoint_name
+        self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+        self.offer_uuid = offer_uuid
+        self.relation_token = relation_token
+        self.remote_endpoint = RemoteEndpoint.from_json(remote_endpoint) if remote_endpoint else None
+        self.remote_space = RemoteSpace.from_json(remote_space) if remote_space else None
+        self.source_model_tag = source_model_tag
+
+
+
+class RegisterRemoteRelationArgs(Type):
+    _toSchema = {'relations': 'relations'}
+    _toPy = {'relations': 'relations'}
+    def __init__(self, relations=None, **unknown_fields):
+        '''
+        relations : typing.Sequence[~RegisterRemoteRelationArg]
+        '''
+        self.relations = [RegisterRemoteRelationArg.from_json(o) for o in relations or []]
+
+
+
+class RegisterRemoteRelationResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : RemoteRelationDetails
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = RemoteRelationDetails.from_json(result) if result else None
+
+
+
+class RegisterRemoteRelationResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~RegisterRemoteRelationResult]
+        '''
+        self.results = [RegisterRemoteRelationResult.from_json(o) for o in results or []]
+
+
+
 class RelationChange(Type):
     _toSchema = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id_': 'id', 'life': 'life'}
     _toPy = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id': 'id_', 'life': 'life'}
     def __init__(self, changedunits=None, departedunits=None, id_=None, life=None, **unknown_fields):
         '''
-        changedunits : typing.Mapping<~KT, +VT_co>[str, ~RelationUnitChange]<~RelationUnitChange>
-        departedunits : typing.Sequence<+T_co>[str]
+        changedunits : typing.Mapping[str, ~RelationUnitChange]
+        departedunits : typing.Sequence[str]
         id_ : int
         life : str
         '''
@@ -5531,12 +7519,44 @@ class RelationIds(Type):
     _toPy = {'relation-ids': 'relation_ids'}
     def __init__(self, relation_ids=None, **unknown_fields):
         '''
-        relation_ids : typing.Sequence<+T_co>[int]
+        relation_ids : typing.Sequence[int]
         '''
         self.relation_ids = relation_ids
 
 
 
+class RelationLifeSuspendedStatusChange(Type):
+    _toSchema = {'key': 'key', 'life': 'life', 'suspended': 'suspended', 'suspended_reason': 'suspended-reason'}
+    _toPy = {'key': 'key', 'life': 'life', 'suspended': 'suspended', 'suspended-reason': 'suspended_reason'}
+    def __init__(self, key=None, life=None, suspended=None, suspended_reason=None, **unknown_fields):
+        '''
+        key : str
+        life : str
+        suspended : bool
+        suspended_reason : str
+        '''
+        self.key = key
+        self.life = life
+        self.suspended = suspended
+        self.suspended_reason = suspended_reason
+
+
+
+class RelationLifeSuspendedStatusWatchResult(Type):
+    _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+    _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
+    def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
+        '''
+        changes : typing.Sequence[~RelationLifeSuspendedStatusChange]
+        error : Error
+        watcher_id : str
+        '''
+        self.changes = [RelationLifeSuspendedStatusChange.from_json(o) for o in changes or []]
+        self.error = Error.from_json(error) if error else None
+        self.watcher_id = watcher_id
+
+
+
 class RelationResult(Type):
     _toSchema = {'endpoint': 'endpoint', 'error': 'error', 'id_': 'id', 'key': 'key', 'life': 'life'}
     _toPy = {'endpoint': 'endpoint', 'error': 'error', 'id': 'id_', 'key': 'key', 'life': 'life'}
@@ -5561,7 +7581,7 @@ class RelationResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~RelationResult]<~RelationResult>
+        results : typing.Sequence[~RelationResult]
         '''
         self.results = [RelationResult.from_json(o) for o in results or []]
 
@@ -5572,7 +7592,7 @@ class RelationStatus(Type):
     _toPy = {'endpoints': 'endpoints', 'id': 'id_', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
     def __init__(self, endpoints=None, id_=None, interface=None, key=None, scope=None, **unknown_fields):
         '''
-        endpoints : typing.Sequence<+T_co>[~EndpointStatus]<~EndpointStatus>
+        endpoints : typing.Sequence[~EndpointStatus]
         id_ : int
         interface : str
         key : str
@@ -5586,6 +7606,71 @@ class RelationStatus(Type):
 
 
 
+class RelationStatusArg(Type):
+    _toSchema = {'message': 'message', 'relation_id': 'relation-id', 'status': 'status', 'unit_tag': 'unit-tag'}
+    _toPy = {'message': 'message', 'relation-id': 'relation_id', 'status': 'status', 'unit-tag': 'unit_tag'}
+    def __init__(self, message=None, relation_id=None, status=None, unit_tag=None, **unknown_fields):
+        '''
+        message : str
+        relation_id : int
+        status : str
+        unit_tag : str
+        '''
+        self.message = message
+        self.relation_id = relation_id
+        self.status = status
+        self.unit_tag = unit_tag
+
+
+
+class RelationStatusArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~RelationStatusArg]
+        '''
+        self.args = [RelationStatusArg.from_json(o) for o in args or []]
+
+
+
+class RelationStatusWatchResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~RelationLifeSuspendedStatusWatchResult]
+        '''
+        self.results = [RelationLifeSuspendedStatusWatchResult.from_json(o) for o in results or []]
+
+
+
+class RelationSuspendedArg(Type):
+    _toSchema = {'message': 'message', 'relation_id': 'relation-id', 'suspended': 'suspended'}
+    _toPy = {'message': 'message', 'relation-id': 'relation_id', 'suspended': 'suspended'}
+    def __init__(self, message=None, relation_id=None, suspended=None, **unknown_fields):
+        '''
+        message : str
+        relation_id : int
+        suspended : bool
+        '''
+        self.message = message
+        self.relation_id = relation_id
+        self.suspended = suspended
+
+
+
+class RelationSuspendedArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~RelationSuspendedArg]
+        '''
+        self.args = [RelationSuspendedArg.from_json(o) for o in args or []]
+
+
+
 class RelationUnit(Type):
     _toSchema = {'relation': 'relation', 'unit': 'unit'}
     _toPy = {'relation': 'relation', 'unit': 'unit'}
@@ -5604,7 +7689,7 @@ class RelationUnitChange(Type):
     _toPy = {'settings': 'settings'}
     def __init__(self, settings=None, **unknown_fields):
         '''
-        settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        settings : typing.Mapping[str, typing.Any]
         '''
         self.settings = settings
 
@@ -5630,7 +7715,7 @@ class RelationUnitPairs(Type):
     _toPy = {'relation-unit-pairs': 'relation_unit_pairs'}
     def __init__(self, relation_unit_pairs=None, **unknown_fields):
         '''
-        relation_unit_pairs : typing.Sequence<+T_co>[~RelationUnitPair]<~RelationUnitPair>
+        relation_unit_pairs : typing.Sequence[~RelationUnitPair]
         '''
         self.relation_unit_pairs = [RelationUnitPair.from_json(o) for o in relation_unit_pairs or []]
 
@@ -5642,7 +7727,7 @@ class RelationUnitSettings(Type):
     def __init__(self, relation=None, settings=None, unit=None, **unknown_fields):
         '''
         relation : str
-        settings : typing.Mapping<~KT, +VT_co>[str, str]
+        settings : typing.Mapping[str, str]
         unit : str
         '''
         self.relation = relation
@@ -5651,12 +7736,51 @@ class RelationUnitSettings(Type):
 
 
 
+class RelationUnitStatus(Type):
+    _toSchema = {'in_scope': 'in-scope', 'relation_tag': 'relation-tag', 'suspended': 'suspended'}
+    _toPy = {'in-scope': 'in_scope', 'relation-tag': 'relation_tag', 'suspended': 'suspended'}
+    def __init__(self, in_scope=None, relation_tag=None, suspended=None, **unknown_fields):
+        '''
+        in_scope : bool
+        relation_tag : str
+        suspended : bool
+        '''
+        self.in_scope = in_scope
+        self.relation_tag = relation_tag
+        self.suspended = suspended
+
+
+
+class RelationUnitStatusResult(Type):
+    _toSchema = {'error': 'error', 'results': 'results'}
+    _toPy = {'error': 'error', 'results': 'results'}
+    def __init__(self, error=None, results=None, **unknown_fields):
+        '''
+        error : Error
+        results : typing.Sequence[~RelationUnitStatus]
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.results = [RelationUnitStatus.from_json(o) for o in results or []]
+
+
+
+class RelationUnitStatusResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~RelationUnitStatusResult]
+        '''
+        self.results = [RelationUnitStatusResult.from_json(o) for o in results or []]
+
+
+
 class RelationUnits(Type):
     _toSchema = {'relation_units': 'relation-units'}
     _toPy = {'relation-units': 'relation_units'}
     def __init__(self, relation_units=None, **unknown_fields):
         '''
-        relation_units : typing.Sequence<+T_co>[~RelationUnit]<~RelationUnit>
+        relation_units : typing.Sequence[~RelationUnit]
         '''
         self.relation_units = [RelationUnit.from_json(o) for o in relation_units or []]
 
@@ -5667,8 +7791,8 @@ class RelationUnitsChange(Type):
     _toPy = {'changed': 'changed', 'departed': 'departed'}
     def __init__(self, changed=None, departed=None, **unknown_fields):
         '''
-        changed : typing.Mapping<~KT, +VT_co>[str, ~UnitSettings]<~UnitSettings>
-        departed : typing.Sequence<+T_co>[str]
+        changed : typing.Mapping[str, ~UnitSettings]
+        departed : typing.Sequence[str]
         '''
         self.changed = changed
         self.departed = departed
@@ -5680,7 +7804,7 @@ class RelationUnitsSettings(Type):
     _toPy = {'relation-units': 'relation_units'}
     def __init__(self, relation_units=None, **unknown_fields):
         '''
-        relation_units : typing.Sequence<+T_co>[~RelationUnitSettings]<~RelationUnitSettings>
+        relation_units : typing.Sequence[~RelationUnitSettings]
         '''
         self.relation_units = [RelationUnitSettings.from_json(o) for o in relation_units or []]
 
@@ -5706,12 +7830,35 @@ class RelationUnitsWatchResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~RelationUnitsWatchResult]<~RelationUnitsWatchResult>
+        results : typing.Sequence[~RelationUnitsWatchResult]
         '''
         self.results = [RelationUnitsWatchResult.from_json(o) for o in results or []]
 
 
 
+class RemoteApplication(Type):
+    _toSchema = {'is_consumer_proxy': 'is-consumer-proxy', 'life': 'life', 'macaroon': 'macaroon', 'model_uuid': 'model-uuid', 'name': 'name', 'offer_uuid': 'offer-uuid', 'status': 'status'}
+    _toPy = {'is-consumer-proxy': 'is_consumer_proxy', 'life': 'life', 'macaroon': 'macaroon', 'model-uuid': 'model_uuid', 'name': 'name', 'offer-uuid': 'offer_uuid', 'status': 'status'}
+    def __init__(self, is_consumer_proxy=None, life=None, macaroon=None, model_uuid=None, name=None, offer_uuid=None, status=None, **unknown_fields):
+        '''
+        is_consumer_proxy : bool
+        life : str
+        macaroon : Macaroon
+        model_uuid : str
+        name : str
+        offer_uuid : str
+        status : str
+        '''
+        self.is_consumer_proxy = is_consumer_proxy
+        self.life = life
+        self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+        self.model_uuid = model_uuid
+        self.name = name
+        self.offer_uuid = offer_uuid
+        self.status = status
+
+
+
 class RemoteApplicationChange(Type):
     _toSchema = {'application_tag': 'application-tag', 'life': 'life', 'relations': 'relations'}
     _toPy = {'application-tag': 'application_tag', 'life': 'life', 'relations': 'relations'}
@@ -5734,7 +7881,7 @@ class RemoteApplicationInfo(Type):
         '''
         application_url : str
         description : str
-        endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
+        endpoints : typing.Sequence[~RemoteEndpoint]
         icon_url_path : str
         model_tag : str
         name : str
@@ -5768,12 +7915,36 @@ class RemoteApplicationInfoResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~RemoteApplicationInfoResult]<~RemoteApplicationInfoResult>
+        results : typing.Sequence[~RemoteApplicationInfoResult]
         '''
         self.results = [RemoteApplicationInfoResult.from_json(o) for o in results or []]
 
 
 
+class RemoteApplicationResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : RemoteApplication
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = RemoteApplication.from_json(result) if result else None
+
+
+
+class RemoteApplicationResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~RemoteApplicationResult]
+        '''
+        self.results = [RemoteApplicationResult.from_json(o) for o in results or []]
+
+
+
 class RemoteApplicationStatus(Type):
     _toSchema = {'application_name': 'application-name', 'application_url': 'application-url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
     _toPy = {'application-name': 'application_name', 'application-url': 'application_url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
@@ -5781,10 +7952,10 @@ class RemoteApplicationStatus(Type):
         '''
         application_name : str
         application_url : str
-        endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
-        err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        endpoints : typing.Sequence[~RemoteEndpoint]
+        err : typing.Mapping[str, typing.Any]
         life : str
-        relations : typing.Sequence<+T_co>[str]
+        relations : typing.Sequence[str]
         status : DetailedStatus
         '''
         self.application_name = application_name
@@ -5831,6 +8002,30 @@ class RemoteEndpoint(Type):
 
 
 
+class RemoteEntityArg(Type):
+    _toSchema = {'macaroons': 'macaroons', 'relation_token': 'relation-token'}
+    _toPy = {'macaroons': 'macaroons', 'relation-token': 'relation_token'}
+    def __init__(self, macaroons=None, relation_token=None, **unknown_fields):
+        '''
+        macaroons : typing.Sequence[~Macaroon]
+        relation_token : str
+        '''
+        self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+        self.relation_token = relation_token
+
+
+
+class RemoteEntityArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~RemoteEntityArg]
+        '''
+        self.args = [RemoteEntityArg.from_json(o) for o in args or []]
+
+
+
 class RemoteEntityId(Type):
     _toSchema = {'model_uuid': 'model-uuid', 'token': 'token'}
     _toPy = {'model-uuid': 'model_uuid', 'token': 'token'}
@@ -5844,13 +8039,64 @@ class RemoteEntityId(Type):
 
 
 
+class RemoteEntityTokenArg(Type):
+    _toSchema = {'tag': 'tag', 'token': 'token'}
+    _toPy = {'tag': 'tag', 'token': 'token'}
+    def __init__(self, tag=None, token=None, **unknown_fields):
+        '''
+        tag : str
+        token : str
+        '''
+        self.tag = tag
+        self.token = token
+
+
+
+class RemoteEntityTokenArgs(Type):
+    _toSchema = {'args': 'Args'}
+    _toPy = {'Args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~RemoteEntityTokenArg]
+        '''
+        self.args = [RemoteEntityTokenArg.from_json(o) for o in args or []]
+
+
+
+class RemoteRelation(Type):
+    _toSchema = {'application_name': 'application-name', 'endpoint': 'endpoint', 'id_': 'id', 'key': 'key', 'life': 'life', 'remote_application_name': 'remote-application-name', 'remote_endpoint_name': 'remote-endpoint-name', 'source_model_uuid': 'source-model-uuid', 'suspended': 'suspended'}
+    _toPy = {'application-name': 'application_name', 'endpoint': 'endpoint', 'id': 'id_', 'key': 'key', 'life': 'life', 'remote-application-name': 'remote_application_name', 'remote-endpoint-name': 'remote_endpoint_name', 'source-model-uuid': 'source_model_uuid', 'suspended': 'suspended'}
+    def __init__(self, application_name=None, endpoint=None, id_=None, key=None, life=None, remote_application_name=None, remote_endpoint_name=None, source_model_uuid=None, suspended=None, **unknown_fields):
+        '''
+        application_name : str
+        endpoint : RemoteEndpoint
+        id_ : int
+        key : str
+        life : str
+        remote_application_name : str
+        remote_endpoint_name : str
+        source_model_uuid : str
+        suspended : bool
+        '''
+        self.application_name = application_name
+        self.endpoint = RemoteEndpoint.from_json(endpoint) if endpoint else None
+        self.id_ = id_
+        self.key = key
+        self.life = life
+        self.remote_application_name = remote_application_name
+        self.remote_endpoint_name = remote_endpoint_name
+        self.source_model_uuid = source_model_uuid
+        self.suspended = suspended
+
+
+
 class RemoteRelationChange(Type):
     _toSchema = {'changed_units': 'changed-units', 'departed_units': 'departed-units', 'id_': 'id', 'life': 'life'}
     _toPy = {'changed-units': 'changed_units', 'departed-units': 'departed_units', 'id': 'id_', 'life': 'life'}
     def __init__(self, changed_units=None, departed_units=None, id_=None, life=None, **unknown_fields):
         '''
-        changed_units : typing.Mapping<~KT, +VT_co>[str, ~RemoteRelationUnitChange]<~RemoteRelationUnitChange>
-        departed_units : typing.Sequence<+T_co>[str]
+        changed_units : typing.Mapping[str, ~RemoteRelationUnitChange]
+        departed_units : typing.Sequence[str]
         id_ : int
         life : str
         '''
@@ -5861,16 +8107,106 @@ class RemoteRelationChange(Type):
 
 
 
+class RemoteRelationChangeEvent(Type):
+    _toSchema = {'application_token': 'application-token', 'changed_units': 'changed-units', 'departed_units': 'departed-units', 'force_cleanup': 'force-cleanup', 'life': 'life', 'macaroons': 'macaroons', 'relation_token': 'relation-token', 'suspended': 'suspended', 'suspended_reason': 'suspended-reason'}
+    _toPy = {'application-token': 'application_token', 'changed-units': 'changed_units', 'departed-units': 'departed_units', 'force-cleanup': 'force_cleanup', 'life': 'life', 'macaroons': 'macaroons', 'relation-token': 'relation_token', 'suspended': 'suspended', 'suspended-reason': 'suspended_reason'}
+    def __init__(self, application_token=None, changed_units=None, departed_units=None, force_cleanup=None, life=None, macaroons=None, relation_token=None, suspended=None, suspended_reason=None, **unknown_fields):
+        '''
+        application_token : str
+        changed_units : typing.Sequence[~RemoteRelationUnitChange]
+        departed_units : typing.Sequence[int]
+        force_cleanup : bool
+        life : str
+        macaroons : typing.Sequence[~Macaroon]
+        relation_token : str
+        suspended : bool
+        suspended_reason : str
+        '''
+        self.application_token = application_token
+        self.changed_units = [RemoteRelationUnitChange.from_json(o) for o in changed_units or []]
+        self.departed_units = departed_units
+        self.force_cleanup = force_cleanup
+        self.life = life
+        self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+        self.relation_token = relation_token
+        self.suspended = suspended
+        self.suspended_reason = suspended_reason
+
+
+
+class RemoteRelationDetails(Type):
+    _toSchema = {'macaroon': 'macaroon', 'relation_token': 'relation-token'}
+    _toPy = {'macaroon': 'macaroon', 'relation-token': 'relation_token'}
+    def __init__(self, macaroon=None, relation_token=None, **unknown_fields):
+        '''
+        macaroon : Macaroon
+        relation_token : str
+        '''
+        self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+        self.relation_token = relation_token
+
+
+
+class RemoteRelationResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : RemoteRelation
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = RemoteRelation.from_json(result) if result else None
+
+
+
+class RemoteRelationResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~RemoteRelationResult]
+        '''
+        self.results = [RemoteRelationResult.from_json(o) for o in results or []]
+
+
+
+class RemoteRelationUnit(Type):
+    _toSchema = {'macaroons': 'macaroons', 'relation_token': 'relation-token', 'unit': 'unit'}
+    _toPy = {'macaroons': 'macaroons', 'relation-token': 'relation_token', 'unit': 'unit'}
+    def __init__(self, macaroons=None, relation_token=None, unit=None, **unknown_fields):
+        '''
+        macaroons : typing.Sequence[~Macaroon]
+        relation_token : str
+        unit : str
+        '''
+        self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+        self.relation_token = relation_token
+        self.unit = unit
+
+
+
 class RemoteRelationUnitChange(Type):
     _toSchema = {'settings': 'settings', 'unit_id': 'unit-id'}
     _toPy = {'settings': 'settings', 'unit-id': 'unit_id'}
     def __init__(self, settings=None, unit_id=None, **unknown_fields):
         '''
-        settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
-        unit_id : RemoteEntityId
+        settings : typing.Mapping[str, typing.Any]
+        unit_id : RemoteEntityId
+        '''
+        self.settings = settings
+        self.unit_id = RemoteEntityId.from_json(unit_id) if unit_id else None
+
+
+
+class RemoteRelationUnits(Type):
+    _toSchema = {'relation_units': 'relation-units'}
+    _toPy = {'relation-units': 'relation_units'}
+    def __init__(self, relation_units=None, **unknown_fields):
+        '''
+        relation_units : typing.Sequence[~RemoteRelationUnit]
         '''
-        self.settings = settings
-        self.unit_id = RemoteEntityId.from_json(unit_id) if unit_id else None
+        self.relation_units = [RemoteRelationUnit.from_json(o) for o in relation_units or []]
 
 
 
@@ -5879,9 +8215,9 @@ class RemoteRelationsChange(Type):
     _toPy = {'changed': 'changed', 'initial': 'initial', 'removed': 'removed'}
     def __init__(self, changed=None, initial=None, removed=None, **unknown_fields):
         '''
-        changed : typing.Sequence<+T_co>[~RemoteRelationChange]<~RemoteRelationChange>
+        changed : typing.Sequence[~RemoteRelationChange]
         initial : bool
-        removed : typing.Sequence<+T_co>[int]
+        removed : typing.Sequence[int]
         '''
         self.changed = [RemoteRelationChange.from_json(o) for o in changed or []]
         self.initial = initial
@@ -5889,6 +8225,17 @@ class RemoteRelationsChange(Type):
 
 
 
+class RemoteRelationsChanges(Type):
+    _toSchema = {'changes': 'changes'}
+    _toPy = {'changes': 'changes'}
+    def __init__(self, changes=None, **unknown_fields):
+        '''
+        changes : typing.Sequence[~RemoteRelationChangeEvent]
+        '''
+        self.changes = [RemoteRelationChangeEvent.from_json(o) for o in changes or []]
+
+
+
 class RemoteRelationsWatchResult(Type):
     _toSchema = {'change': 'change', 'error': 'error', 'remoterelationswatcherid': 'RemoteRelationsWatcherId'}
     _toPy = {'RemoteRelationsWatcherId': 'remoterelationswatcherid', 'change': 'change', 'error': 'error'}
@@ -5911,9 +8258,9 @@ class RemoteSpace(Type):
         '''
         cloud_type : str
         name : str
-        provider_attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        provider_attributes : typing.Mapping[str, typing.Any]
         provider_id : str
-        subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+        subnets : typing.Sequence[~Subnet]
         '''
         self.cloud_type = cloud_type
         self.name = name
@@ -5934,6 +8281,110 @@ class RemoveBlocksArgs(Type):
 
 
 
+class RemoveFilesystemParams(Type):
+    _toSchema = {'destroy': 'destroy', 'filesystem_id': 'filesystem-id', 'provider': 'provider'}
+    _toPy = {'destroy': 'destroy', 'filesystem-id': 'filesystem_id', 'provider': 'provider'}
+    def __init__(self, destroy=None, filesystem_id=None, provider=None, **unknown_fields):
+        '''
+        destroy : bool
+        filesystem_id : str
+        provider : str
+        '''
+        self.destroy = destroy
+        self.filesystem_id = filesystem_id
+        self.provider = provider
+
+
+
+class RemoveFilesystemParamsResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : RemoveFilesystemParams
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = RemoveFilesystemParams.from_json(result) if result else None
+
+
+
+class RemoveFilesystemParamsResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~RemoveFilesystemParamsResult]
+        '''
+        self.results = [RemoveFilesystemParamsResult.from_json(o) for o in results or []]
+
+
+
+class RemoveStorage(Type):
+    _toSchema = {'storage': 'storage'}
+    _toPy = {'storage': 'storage'}
+    def __init__(self, storage=None, **unknown_fields):
+        '''
+        storage : typing.Sequence[~RemoveStorageInstance]
+        '''
+        self.storage = [RemoveStorageInstance.from_json(o) for o in storage or []]
+
+
+
+class RemoveStorageInstance(Type):
+    _toSchema = {'destroy_attachments': 'destroy-attachments', 'destroy_storage': 'destroy-storage', 'tag': 'tag'}
+    _toPy = {'destroy-attachments': 'destroy_attachments', 'destroy-storage': 'destroy_storage', 'tag': 'tag'}
+    def __init__(self, destroy_attachments=None, destroy_storage=None, tag=None, **unknown_fields):
+        '''
+        destroy_attachments : bool
+        destroy_storage : bool
+        tag : str
+        '''
+        self.destroy_attachments = destroy_attachments
+        self.destroy_storage = destroy_storage
+        self.tag = tag
+
+
+
+class RemoveVolumeParams(Type):
+    _toSchema = {'destroy': 'destroy', 'provider': 'provider', 'volume_id': 'volume-id'}
+    _toPy = {'destroy': 'destroy', 'provider': 'provider', 'volume-id': 'volume_id'}
+    def __init__(self, destroy=None, provider=None, volume_id=None, **unknown_fields):
+        '''
+        destroy : bool
+        provider : str
+        volume_id : str
+        '''
+        self.destroy = destroy
+        self.provider = provider
+        self.volume_id = volume_id
+
+
+
+class RemoveVolumeParamsResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : RemoveVolumeParams
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = RemoveVolumeParams.from_json(result) if result else None
+
+
+
+class RemoveVolumeParamsResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~RemoveVolumeParamsResult]
+        '''
+        self.results = [RemoveVolumeParamsResult.from_json(o) for o in results or []]
+
+
+
 class ResolveCharmResult(Type):
     _toSchema = {'error': 'error', 'url': 'url'}
     _toPy = {'error': 'error', 'url': 'url'}
@@ -5952,7 +8403,7 @@ class ResolveCharmResults(Type):
     _toPy = {'urls': 'urls'}
     def __init__(self, urls=None, **unknown_fields):
         '''
-        urls : typing.Sequence<+T_co>[~ResolveCharmResult]<~ResolveCharmResult>
+        urls : typing.Sequence[~ResolveCharmResult]
         '''
         self.urls = [ResolveCharmResult.from_json(o) for o in urls or []]
 
@@ -5963,7 +8414,7 @@ class ResolveCharms(Type):
     _toPy = {'references': 'references'}
     def __init__(self, references=None, **unknown_fields):
         '''
-        references : typing.Sequence<+T_co>[str]
+        references : typing.Sequence[str]
         '''
         self.references = references
 
@@ -6000,7 +8451,7 @@ class ResolvedModeResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ResolvedModeResult]<~ResolvedModeResult>
+        results : typing.Sequence[~ResolvedModeResult]
         '''
         self.results = [ResolvedModeResult.from_json(o) for o in results or []]
 
@@ -6046,9 +8497,9 @@ class ResourcesResult(Type):
     def __init__(self, errorresult=None, charm_store_resources=None, resources=None, unit_resources=None, **unknown_fields):
         '''
         errorresult : ErrorResult
-        charm_store_resources : typing.Sequence<+T_co>[~CharmResource]<~CharmResource>
-        resources : typing.Sequence<+T_co>[~Resource]<~Resource>
-        unit_resources : typing.Sequence<+T_co>[~UnitResources]<~UnitResources>
+        charm_store_resources : typing.Sequence[~CharmResource]
+        resources : typing.Sequence[~Resource]
+        unit_resources : typing.Sequence[~UnitResources]
         '''
         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
         self.charm_store_resources = [CharmResource.from_json(o) for o in charm_store_resources or []]
@@ -6062,7 +8513,7 @@ class ResourcesResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ResourcesResult]<~ResourcesResult>
+        results : typing.Sequence[~ResourcesResult]
         '''
         self.results = [ResourcesResult.from_json(o) for o in results or []]
 
@@ -6084,7 +8535,7 @@ class ResumeReplicationParams(Type):
     _toPy = {'members': 'members'}
     def __init__(self, members=None, **unknown_fields):
         '''
-        members : typing.Sequence<+T_co>[~Member]<~Member>
+        members : typing.Sequence[~Member]
         '''
         self.members = [Member.from_json(o) for o in members or []]
 
@@ -6127,22 +8578,46 @@ class RetryStrategyResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~RetryStrategyResult]<~RetryStrategyResult>
+        results : typing.Sequence[~RetryStrategyResult]
         '''
         self.results = [RetryStrategyResult.from_json(o) for o in results or []]
 
 
 
+class RevokeCredentialArg(Type):
+    _toSchema = {'force': 'force', 'tag': 'tag'}
+    _toPy = {'force': 'force', 'tag': 'tag'}
+    def __init__(self, force=None, tag=None, **unknown_fields):
+        '''
+        force : bool
+        tag : str
+        '''
+        self.force = force
+        self.tag = tag
+
+
+
+class RevokeCredentialArgs(Type):
+    _toSchema = {'credentials': 'credentials'}
+    _toPy = {'credentials': 'credentials'}
+    def __init__(self, credentials=None, **unknown_fields):
+        '''
+        credentials : typing.Sequence[~RevokeCredentialArg]
+        '''
+        self.credentials = [RevokeCredentialArg.from_json(o) for o in credentials or []]
+
+
+
 class RunParams(Type):
     _toSchema = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
     _toPy = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
     def __init__(self, applications=None, commands=None, machines=None, timeout=None, units=None, **unknown_fields):
         '''
-        applications : typing.Sequence<+T_co>[str]
+        applications : typing.Sequence[str]
         commands : str
-        machines : typing.Sequence<+T_co>[str]
+        machines : typing.Sequence[str]
         timeout : int
-        units : typing.Sequence<+T_co>[str]
+        units : typing.Sequence[str]
         '''
         self.applications = applications
         self.commands = commands
@@ -6170,7 +8645,7 @@ class SSHAddressResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~SSHAddressResult]<~SSHAddressResult>
+        results : typing.Sequence[~SSHAddressResult]
         '''
         self.results = [SSHAddressResult.from_json(o) for o in results or []]
 
@@ -6181,7 +8656,7 @@ class SSHAddressesResult(Type):
     _toPy = {'addresses': 'addresses', 'error': 'error'}
     def __init__(self, addresses=None, error=None, **unknown_fields):
         '''
-        addresses : typing.Sequence<+T_co>[str]
+        addresses : typing.Sequence[str]
         error : Error
         '''
         self.addresses = addresses
@@ -6194,7 +8669,7 @@ class SSHAddressesResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~SSHAddressesResult]<~SSHAddressesResult>
+        results : typing.Sequence[~SSHAddressesResult]
         '''
         self.results = [SSHAddressesResult.from_json(o) for o in results or []]
 
@@ -6205,7 +8680,7 @@ class SSHHostKeySet(Type):
     _toPy = {'entity-keys': 'entity_keys'}
     def __init__(self, entity_keys=None, **unknown_fields):
         '''
-        entity_keys : typing.Sequence<+T_co>[~SSHHostKeys]<~SSHHostKeys>
+        entity_keys : typing.Sequence[~SSHHostKeys]
         '''
         self.entity_keys = [SSHHostKeys.from_json(o) for o in entity_keys or []]
 
@@ -6216,7 +8691,7 @@ class SSHHostKeys(Type):
     _toPy = {'public-keys': 'public_keys', 'tag': 'tag'}
     def __init__(self, public_keys=None, tag=None, **unknown_fields):
         '''
-        public_keys : typing.Sequence<+T_co>[str]
+        public_keys : typing.Sequence[str]
         tag : str
         '''
         self.public_keys = public_keys
@@ -6241,7 +8716,7 @@ class SSHPublicKeysResult(Type):
     def __init__(self, error=None, public_keys=None, **unknown_fields):
         '''
         error : Error
-        public_keys : typing.Sequence<+T_co>[str]
+        public_keys : typing.Sequence[str]
         '''
         self.error = Error.from_json(error) if error else None
         self.public_keys = public_keys
@@ -6253,20 +8728,81 @@ class SSHPublicKeysResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~SSHPublicKeysResult]<~SSHPublicKeysResult>
+        results : typing.Sequence[~SSHPublicKeysResult]
         '''
         self.results = [SSHPublicKeysResult.from_json(o) for o in results or []]
 
 
 
+class ScaleApplicationInfo(Type):
+    _toSchema = {'num_units': 'num-units'}
+    _toPy = {'num-units': 'num_units'}
+    def __init__(self, num_units=None, **unknown_fields):
+        '''
+        num_units : int
+        '''
+        self.num_units = num_units
+
+
+
+class ScaleApplicationParams(Type):
+    _toSchema = {'application_tag': 'application-tag', 'scale': 'scale', 'scale_change': 'scale-change'}
+    _toPy = {'application-tag': 'application_tag', 'scale': 'scale', 'scale-change': 'scale_change'}
+    def __init__(self, application_tag=None, scale=None, scale_change=None, **unknown_fields):
+        '''
+        application_tag : str
+        scale : int
+        scale_change : int
+        '''
+        self.application_tag = application_tag
+        self.scale = scale
+        self.scale_change = scale_change
+
+
+
+class ScaleApplicationResult(Type):
+    _toSchema = {'error': 'error', 'info': 'info'}
+    _toPy = {'error': 'error', 'info': 'info'}
+    def __init__(self, error=None, info=None, **unknown_fields):
+        '''
+        error : Error
+        info : ScaleApplicationInfo
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.info = ScaleApplicationInfo.from_json(info) if info else None
+
+
+
+class ScaleApplicationResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~ScaleApplicationResult]
+        '''
+        self.results = [ScaleApplicationResult.from_json(o) for o in results or []]
+
+
+
+class ScaleApplicationsParams(Type):
+    _toSchema = {'applications': 'applications'}
+    _toPy = {'applications': 'applications'}
+    def __init__(self, applications=None, **unknown_fields):
+        '''
+        applications : typing.Sequence[~ScaleApplicationParams]
+        '''
+        self.applications = [ScaleApplicationParams.from_json(o) for o in applications or []]
+
+
+
 class SerializedModel(Type):
     _toSchema = {'bytes_': 'bytes', 'charms': 'charms', 'tools': 'tools'}
     _toPy = {'bytes': 'bytes_', 'charms': 'charms', 'tools': 'tools'}
     def __init__(self, bytes_=None, charms=None, tools=None, **unknown_fields):
         '''
-        bytes_ : typing.Sequence<+T_co>[int]
-        charms : typing.Sequence<+T_co>[str]
-        tools : typing.Sequence<+T_co>[~SerializedModelTools]<~SerializedModelTools>
+        bytes_ : typing.Sequence[int]
+        charms : typing.Sequence[str]
+        tools : typing.Sequence[~SerializedModelTools]
         '''
         self.bytes_ = bytes_
         self.charms = charms
@@ -6283,7 +8819,7 @@ class SerializedModelResource(Type):
         application_revision : SerializedModelResourceRevision
         charmstore_revision : SerializedModelResourceRevision
         name : str
-        unit_revisions : typing.Mapping<~KT, +VT_co>[str, ~SerializedModelResourceRevision]<~SerializedModelResourceRevision>
+        unit_revisions : typing.Mapping[str, ~SerializedModelResourceRevision]
         '''
         self.application = application
         self.application_revision = SerializedModelResourceRevision.from_json(application_revision) if application_revision else None
@@ -6346,12 +8882,34 @@ class SetConstraints(Type):
 
 
 
+class SetExternalControllerInfoParams(Type):
+    _toSchema = {'info': 'info'}
+    _toPy = {'info': 'info'}
+    def __init__(self, info=None, **unknown_fields):
+        '''
+        info : ExternalControllerInfo
+        '''
+        self.info = ExternalControllerInfo.from_json(info) if info else None
+
+
+
+class SetExternalControllersInfoParams(Type):
+    _toSchema = {'controllers': 'controllers'}
+    _toPy = {'controllers': 'controllers'}
+    def __init__(self, controllers=None, **unknown_fields):
+        '''
+        controllers : typing.Sequence[~SetExternalControllerInfoParams]
+        '''
+        self.controllers = [SetExternalControllerInfoParams.from_json(o) for o in controllers or []]
+
+
+
 class SetMachineBlockDevices(Type):
     _toSchema = {'machine_block_devices': 'machine-block-devices'}
     _toPy = {'machine-block-devices': 'machine_block_devices'}
     def __init__(self, machine_block_devices=None, **unknown_fields):
         '''
-        machine_block_devices : typing.Sequence<+T_co>[~MachineBlockDevices]<~MachineBlockDevices>
+        machine_block_devices : typing.Sequence[~MachineBlockDevices]
         '''
         self.machine_block_devices = [MachineBlockDevices.from_json(o) for o in machine_block_devices or []]
 
@@ -6362,7 +8920,7 @@ class SetMachineNetworkConfig(Type):
     _toPy = {'config': 'config', 'tag': 'tag'}
     def __init__(self, config=None, tag=None, **unknown_fields):
         '''
-        config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+        config : typing.Sequence[~NetworkConfig]
         tag : str
         '''
         self.config = [NetworkConfig.from_json(o) for o in config or []]
@@ -6375,7 +8933,7 @@ class SetMachinesAddresses(Type):
     _toPy = {'machine-addresses': 'machine_addresses'}
     def __init__(self, machine_addresses=None, **unknown_fields):
         '''
-        machine_addresses : typing.Sequence<+T_co>[~MachineAddresses]<~MachineAddresses>
+        machine_addresses : typing.Sequence[~MachineAddresses]
         '''
         self.machine_addresses = [MachineAddresses.from_json(o) for o in machine_addresses or []]
 
@@ -6419,12 +8977,36 @@ class SetModelDefaults(Type):
     _toPy = {'config': 'config'}
     def __init__(self, config=None, **unknown_fields):
         '''
-        config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
+        config : typing.Sequence[~ModelDefaultValues]
         '''
         self.config = [ModelDefaultValues.from_json(o) for o in config or []]
 
 
 
+class SetModelEnvironVersion(Type):
+    _toSchema = {'model_tag': 'model-tag', 'version': 'version'}
+    _toPy = {'model-tag': 'model_tag', 'version': 'version'}
+    def __init__(self, model_tag=None, version=None, **unknown_fields):
+        '''
+        model_tag : str
+        version : int
+        '''
+        self.model_tag = model_tag
+        self.version = version
+
+
+
+class SetModelEnvironVersions(Type):
+    _toSchema = {'models': 'models'}
+    _toPy = {'models': 'models'}
+    def __init__(self, models=None, **unknown_fields):
+        '''
+        models : typing.Sequence[~SetModelEnvironVersion]
+        '''
+        self.models = [SetModelEnvironVersion.from_json(o) for o in models or []]
+
+
+
 class SetPayloadStatusArg(Type):
     _toSchema = {'entity': 'Entity', 'status': 'status'}
     _toPy = {'Entity': 'entity', 'status': 'status'}
@@ -6443,18 +9025,77 @@ class SetPayloadStatusArgs(Type):
     _toPy = {'args': 'args'}
     def __init__(self, args=None, **unknown_fields):
         '''
-        args : typing.Sequence<+T_co>[~SetPayloadStatusArg]<~SetPayloadStatusArg>
+        args : typing.Sequence[~SetPayloadStatusArg]
         '''
         self.args = [SetPayloadStatusArg.from_json(o) for o in args or []]
 
 
 
+class SetPodSpecParams(Type):
+    _toSchema = {'specs': 'specs'}
+    _toPy = {'specs': 'specs'}
+    def __init__(self, specs=None, **unknown_fields):
+        '''
+        specs : typing.Sequence[~EntityString]
+        '''
+        self.specs = [EntityString.from_json(o) for o in specs or []]
+
+
+
+class SetProfileArg(Type):
+    _toSchema = {'entity': 'entity', 'profiles': 'profiles'}
+    _toPy = {'entity': 'entity', 'profiles': 'profiles'}
+    def __init__(self, entity=None, profiles=None, **unknown_fields):
+        '''
+        entity : Entity
+        profiles : typing.Sequence[str]
+        '''
+        self.entity = Entity.from_json(entity) if entity else None
+        self.profiles = profiles
+
+
+
+class SetProfileArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~SetProfileArg]
+        '''
+        self.args = [SetProfileArg.from_json(o) for o in args or []]
+
+
+
+class SetProfileUpgradeCompleteArg(Type):
+    _toSchema = {'entity': 'entity', 'message': 'message'}
+    _toPy = {'entity': 'entity', 'message': 'message'}
+    def __init__(self, entity=None, message=None, **unknown_fields):
+        '''
+        entity : Entity
+        message : str
+        '''
+        self.entity = Entity.from_json(entity) if entity else None
+        self.message = message
+
+
+
+class SetProfileUpgradeCompleteArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~SetProfileUpgradeCompleteArg]
+        '''
+        self.args = [SetProfileUpgradeCompleteArg.from_json(o) for o in args or []]
+
+
+
 class SetStatus(Type):
     _toSchema = {'entities': 'entities'}
     _toPy = {'entities': 'entities'}
     def __init__(self, entities=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
+        entities : typing.Sequence[~EntityStatusArgs]
         '''
         self.entities = [EntityStatusArgs.from_json(o) for o in entities or []]
 
@@ -6478,7 +9119,7 @@ class SetStatusArgs(Type):
     _toPy = {'args': 'args'}
     def __init__(self, args=None, **unknown_fields):
         '''
-        args : typing.Sequence<+T_co>[~SetStatusArg]<~SetStatusArg>
+        args : typing.Sequence[~SetStatusArg]
         '''
         self.args = [SetStatusArg.from_json(o) for o in args or []]
 
@@ -6507,7 +9148,7 @@ class SettingsResult(Type):
     def __init__(self, error=None, settings=None, **unknown_fields):
         '''
         error : Error
-        settings : typing.Mapping<~KT, +VT_co>[str, str]
+        settings : typing.Mapping[str, str]
         '''
         self.error = Error.from_json(error) if error else None
         self.settings = settings
@@ -6519,7 +9160,7 @@ class SettingsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~SettingsResult]<~SettingsResult>
+        results : typing.Sequence[~SettingsResult]
         '''
         self.results = [SettingsResult.from_json(o) for o in results or []]
 
@@ -6545,7 +9186,7 @@ class SingularClaims(Type):
     _toPy = {'claims': 'claims'}
     def __init__(self, claims=None, **unknown_fields):
         '''
-        claims : typing.Sequence<+T_co>[~SingularClaim]<~SingularClaim>
+        claims : typing.Sequence[~SingularClaim]
         '''
         self.claims = [SingularClaim.from_json(o) for o in claims or []]
 
@@ -6558,7 +9199,7 @@ class Space(Type):
         '''
         error : Error
         name : str
-        subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+        subnets : typing.Sequence[~Subnet]
         '''
         self.error = Error.from_json(error) if error else None
         self.name = name
@@ -6584,7 +9225,7 @@ class SpaceResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~SpaceResult]<~SpaceResult>
+        results : typing.Sequence[~SpaceResult]
         '''
         self.results = [SpaceResult.from_json(o) for o in results or []]
 
@@ -6663,7 +9304,7 @@ class StatusHistoryRequests(Type):
     _toPy = {'requests': 'requests'}
     def __init__(self, requests=None, **unknown_fields):
         '''
-        requests : typing.Sequence<+T_co>[~StatusHistoryRequest]<~StatusHistoryRequest>
+        requests : typing.Sequence[~StatusHistoryRequest]
         '''
         self.requests = [StatusHistoryRequest.from_json(o) for o in requests or []]
 
@@ -6687,7 +9328,7 @@ class StatusHistoryResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StatusHistoryResult]<~StatusHistoryResult>
+        results : typing.Sequence[~StatusHistoryResult]
         '''
         self.results = [StatusHistoryResult.from_json(o) for o in results or []]
 
@@ -6698,7 +9339,7 @@ class StatusParams(Type):
     _toPy = {'patterns': 'patterns'}
     def __init__(self, patterns=None, **unknown_fields):
         '''
-        patterns : typing.Sequence<+T_co>[str]
+        patterns : typing.Sequence[str]
         '''
         self.patterns = patterns
 
@@ -6709,7 +9350,7 @@ class StatusResult(Type):
     _toPy = {'data': 'data', 'error': 'error', 'id': 'id_', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
     def __init__(self, data=None, error=None, id_=None, info=None, life=None, since=None, status=None, **unknown_fields):
         '''
-        data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        data : typing.Mapping[str, typing.Any]
         error : Error
         id_ : str
         info : str
@@ -6732,7 +9373,7 @@ class StatusResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
+        results : typing.Sequence[~StatusResult]
         '''
         self.results = [StatusResult.from_json(o) for o in results or []]
 
@@ -6809,7 +9450,7 @@ class StorageAttachmentIds(Type):
     _toPy = {'ids': 'ids'}
     def __init__(self, ids=None, **unknown_fields):
         '''
-        ids : typing.Sequence<+T_co>[~StorageAttachmentId]<~StorageAttachmentId>
+        ids : typing.Sequence[~StorageAttachmentId]
         '''
         self.ids = [StorageAttachmentId.from_json(o) for o in ids or []]
 
@@ -6833,7 +9474,7 @@ class StorageAttachmentIdsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StorageAttachmentIdsResult]<~StorageAttachmentIdsResult>
+        results : typing.Sequence[~StorageAttachmentIdsResult]
         '''
         self.results = [StorageAttachmentIdsResult.from_json(o) for o in results or []]
 
@@ -6857,7 +9498,7 @@ class StorageAttachmentResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StorageAttachmentResult]<~StorageAttachmentResult>
+        results : typing.Sequence[~StorageAttachmentResult]
         '''
         self.results = [StorageAttachmentResult.from_json(o) for o in results or []]
 
@@ -6883,7 +9524,7 @@ class StorageDetails(Type):
     _toPy = {'attachments': 'attachments', 'kind': 'kind', 'owner-tag': 'owner_tag', 'persistent': 'persistent', 'status': 'status', 'storage-tag': 'storage_tag'}
     def __init__(self, attachments=None, kind=None, owner_tag=None, persistent=None, status=None, storage_tag=None, **unknown_fields):
         '''
-        attachments : typing.Mapping<~KT, +VT_co>[str, ~StorageAttachmentDetails]<~StorageAttachmentDetails>
+        attachments : typing.Mapping[str, ~StorageAttachmentDetails]
         kind : int
         owner_tag : str
         persistent : bool
@@ -6905,7 +9546,7 @@ class StorageDetailsListResult(Type):
     def __init__(self, error=None, result=None, **unknown_fields):
         '''
         error : Error
-        result : typing.Sequence<+T_co>[~StorageDetails]<~StorageDetails>
+        result : typing.Sequence[~StorageDetails]
         '''
         self.error = Error.from_json(error) if error else None
         self.result = [StorageDetails.from_json(o) for o in result or []]
@@ -6917,7 +9558,7 @@ class StorageDetailsListResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StorageDetailsListResult]<~StorageDetailsListResult>
+        results : typing.Sequence[~StorageDetailsListResult]
         '''
         self.results = [StorageDetailsListResult.from_json(o) for o in results or []]
 
@@ -6941,7 +9582,7 @@ class StorageDetailsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StorageDetailsResult]<~StorageDetailsResult>
+        results : typing.Sequence[~StorageDetailsResult]
         '''
         self.results = [StorageDetailsResult.from_json(o) for o in results or []]
 
@@ -6963,7 +9604,7 @@ class StorageFilters(Type):
     _toPy = {'filters': 'filters'}
     def __init__(self, filters=None, **unknown_fields):
         '''
-        filters : typing.Sequence<+T_co>[~StorageFilter]<~StorageFilter>
+        filters : typing.Sequence[~StorageFilter]
         '''
         self.filters = [StorageFilter.from_json(o) for o in filters or []]
 
@@ -6974,7 +9615,7 @@ class StoragePool(Type):
     _toPy = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
     def __init__(self, attrs=None, name=None, provider=None, **unknown_fields):
         '''
-        attrs : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        attrs : typing.Mapping[str, typing.Any]
         name : str
         provider : str
         '''
@@ -6989,8 +9630,8 @@ class StoragePoolFilter(Type):
     _toPy = {'names': 'names', 'providers': 'providers'}
     def __init__(self, names=None, providers=None, **unknown_fields):
         '''
-        names : typing.Sequence<+T_co>[str]
-        providers : typing.Sequence<+T_co>[str]
+        names : typing.Sequence[str]
+        providers : typing.Sequence[str]
         '''
         self.names = names
         self.providers = providers
@@ -7002,7 +9643,7 @@ class StoragePoolFilters(Type):
     _toPy = {'filters': 'filters'}
     def __init__(self, filters=None, **unknown_fields):
         '''
-        filters : typing.Sequence<+T_co>[~StoragePoolFilter]<~StoragePoolFilter>
+        filters : typing.Sequence[~StoragePoolFilter]
         '''
         self.filters = [StoragePoolFilter.from_json(o) for o in filters or []]
 
@@ -7014,7 +9655,7 @@ class StoragePoolsResult(Type):
     def __init__(self, error=None, storage_pools=None, **unknown_fields):
         '''
         error : Error
-        storage_pools : typing.Sequence<+T_co>[~StoragePool]<~StoragePool>
+        storage_pools : typing.Sequence[~StoragePool]
         '''
         self.error = Error.from_json(error) if error else None
         self.storage_pools = [StoragePool.from_json(o) for o in storage_pools or []]
@@ -7026,7 +9667,7 @@ class StoragePoolsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StoragePoolsResult]<~StoragePoolsResult>
+        results : typing.Sequence[~StoragePoolsResult]
         '''
         self.results = [StoragePoolsResult.from_json(o) for o in results or []]
 
@@ -7037,7 +9678,7 @@ class StoragesAddParams(Type):
     _toPy = {'storages': 'storages'}
     def __init__(self, storages=None, **unknown_fields):
         '''
-        storages : typing.Sequence<+T_co>[~StorageAddParams]<~StorageAddParams>
+        storages : typing.Sequence[~StorageAddParams]
         '''
         self.storages = [StorageAddParams.from_json(o) for o in storages or []]
 
@@ -7063,7 +9704,7 @@ class StringBoolResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StringBoolResult]<~StringBoolResult>
+        results : typing.Sequence[~StringBoolResult]
         '''
         self.results = [StringBoolResult.from_json(o) for o in results or []]
 
@@ -7087,7 +9728,7 @@ class StringResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StringResult]<~StringResult>
+        results : typing.Sequence[~StringResult]
         '''
         self.results = [StringResult.from_json(o) for o in results or []]
 
@@ -7099,7 +9740,7 @@ class StringsResult(Type):
     def __init__(self, error=None, result=None, **unknown_fields):
         '''
         error : Error
-        result : typing.Sequence<+T_co>[str]
+        result : typing.Sequence[str]
         '''
         self.error = Error.from_json(error) if error else None
         self.result = result
@@ -7111,7 +9752,7 @@ class StringsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
+        results : typing.Sequence[~StringsResult]
         '''
         self.results = [StringsResult.from_json(o) for o in results or []]
 
@@ -7122,7 +9763,7 @@ class StringsWatchResult(Type):
     _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
     def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
         '''
-        changes : typing.Sequence<+T_co>[str]
+        changes : typing.Sequence[str]
         error : Error
         watcher_id : str
         '''
@@ -7137,45 +9778,93 @@ class StringsWatchResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+        results : typing.Sequence[~StringsWatchResult]
+        '''
+        self.results = [StringsWatchResult.from_json(o) for o in results or []]
+
+
+
+class Subnet(Type):
+    _toSchema = {'cidr': 'cidr', 'life': 'life', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'status': 'status', 'vlan_tag': 'vlan-tag', 'zones': 'zones'}
+    _toPy = {'cidr': 'cidr', 'life': 'life', 'provider-id': 'provider_id', 'space-tag': 'space_tag', 'status': 'status', 'vlan-tag': 'vlan_tag', 'zones': 'zones'}
+    def __init__(self, cidr=None, life=None, provider_id=None, space_tag=None, status=None, vlan_tag=None, zones=None, **unknown_fields):
+        '''
+        cidr : str
+        life : str
+        provider_id : str
+        space_tag : str
+        status : str
+        vlan_tag : int
+        zones : typing.Sequence[str]
+        '''
+        self.cidr = cidr
+        self.life = life
+        self.provider_id = provider_id
+        self.space_tag = space_tag
+        self.status = status
+        self.vlan_tag = vlan_tag
+        self.zones = zones
+
+
+
+class SubnetsFilters(Type):
+    _toSchema = {'space_tag': 'space-tag', 'zone': 'zone'}
+    _toPy = {'space-tag': 'space_tag', 'zone': 'zone'}
+    def __init__(self, space_tag=None, zone=None, **unknown_fields):
+        '''
+        space_tag : str
+        zone : str
+        '''
+        self.space_tag = space_tag
+        self.zone = zone
+
+
+
+class TaggedCredential(Type):
+    _toSchema = {'credential': 'credential', 'tag': 'tag'}
+    _toPy = {'credential': 'credential', 'tag': 'tag'}
+    def __init__(self, credential=None, tag=None, **unknown_fields):
+        '''
+        credential : CloudCredential
+        tag : str
+        '''
+        self.credential = CloudCredential.from_json(credential) if credential else None
+        self.tag = tag
+
+
+
+class TaggedCredentials(Type):
+    _toSchema = {'credentials': 'credentials'}
+    _toPy = {'credentials': 'credentials'}
+    def __init__(self, credentials=None, **unknown_fields):
+        '''
+        credentials : typing.Sequence[~TaggedCredential]
         '''
-        self.results = [StringsWatchResult.from_json(o) for o in results or []]
+        self.credentials = [TaggedCredential.from_json(o) for o in credentials or []]
 
 
 
-class Subnet(Type):
-    _toSchema = {'cidr': 'cidr', 'life': 'life', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'status': 'status', 'vlan_tag': 'vlan-tag', 'zones': 'zones'}
-    _toPy = {'cidr': 'cidr', 'life': 'life', 'provider-id': 'provider_id', 'space-tag': 'space_tag', 'status': 'status', 'vlan-tag': 'vlan_tag', 'zones': 'zones'}
-    def __init__(self, cidr=None, life=None, provider_id=None, space_tag=None, status=None, vlan_tag=None, zones=None, **unknown_fields):
+class TokenResult(Type):
+    _toSchema = {'error': 'error', 'token': 'token'}
+    _toPy = {'error': 'error', 'token': 'token'}
+    def __init__(self, error=None, token=None, **unknown_fields):
         '''
-        cidr : str
-        life : str
-        provider_id : str
-        space_tag : str
-        status : str
-        vlan_tag : int
-        zones : typing.Sequence<+T_co>[str]
+        error : Error
+        token : str
         '''
-        self.cidr = cidr
-        self.life = life
-        self.provider_id = provider_id
-        self.space_tag = space_tag
-        self.status = status
-        self.vlan_tag = vlan_tag
-        self.zones = zones
+        self.error = Error.from_json(error) if error else None
+        self.token = token
 
 
 
-class SubnetsFilters(Type):
-    _toSchema = {'space_tag': 'space-tag', 'zone': 'zone'}
-    _toPy = {'space-tag': 'space_tag', 'zone': 'zone'}
-    def __init__(self, space_tag=None, zone=None, **unknown_fields):
+class TokenResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
         '''
-        space_tag : str
-        zone : str
+        results : typing.Sequence[~TokenResult]
         '''
-        self.space_tag = space_tag
-        self.zone = zone
+        self.results = [TokenResult.from_json(o) for o in results or []]
 
 
 
@@ -7203,7 +9892,7 @@ class ToolsResult(Type):
         '''
         disable_ssl_hostname_verification : bool
         error : Error
-        tools : typing.Sequence<+T_co>[~Tools]<~Tools>
+        tools : typing.Sequence[~Tools]
         '''
         self.disable_ssl_hostname_verification = disable_ssl_hostname_verification
         self.error = Error.from_json(error) if error else None
@@ -7216,7 +9905,7 @@ class ToolsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ToolsResult]<~ToolsResult>
+        results : typing.Sequence[~ToolsResult]
         '''
         self.results = [ToolsResult.from_json(o) for o in results or []]
 
@@ -7227,7 +9916,7 @@ class TrackArgs(Type):
     _toPy = {'payloads': 'payloads'}
     def __init__(self, payloads=None, **unknown_fields):
         '''
-        payloads : typing.Sequence<+T_co>[~Payload]<~Payload>
+        payloads : typing.Sequence[~Payload]
         '''
         self.payloads = [Payload.from_json(o) for o in payloads or []]
 
@@ -7238,7 +9927,7 @@ class TrackPayloadArgs(Type):
     _toPy = {'payloads': 'payloads'}
     def __init__(self, payloads=None, **unknown_fields):
         '''
-        payloads : typing.Sequence<+T_co>[~Payload]<~Payload>
+        payloads : typing.Sequence[~Payload]
         '''
         self.payloads = [Payload.from_json(o) for o in payloads or []]
 
@@ -7295,7 +9984,7 @@ class UnitNetworkConfigResult(Type):
     def __init__(self, error=None, info=None, **unknown_fields):
         '''
         error : Error
-        info : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+        info : typing.Sequence[~NetworkConfig]
         '''
         self.error = Error.from_json(error) if error else None
         self.info = [NetworkConfig.from_json(o) for o in info or []]
@@ -7307,12 +9996,38 @@ class UnitNetworkConfigResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~UnitNetworkConfigResult]<~UnitNetworkConfigResult>
+        results : typing.Sequence[~UnitNetworkConfigResult]
         '''
         self.results = [UnitNetworkConfigResult.from_json(o) for o in results or []]
 
 
 
+class UnitRefreshResult(Type):
+    _toSchema = {'error': 'Error', 'life': 'Life', 'resolved': 'Resolved'}
+    _toPy = {'Error': 'error', 'Life': 'life', 'Resolved': 'resolved'}
+    def __init__(self, error=None, life=None, resolved=None, **unknown_fields):
+        '''
+        error : Error
+        life : str
+        resolved : str
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.life = life
+        self.resolved = resolved
+
+
+
+class UnitRefreshResults(Type):
+    _toSchema = {'results': 'Results'}
+    _toPy = {'Results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~UnitRefreshResult]
+        '''
+        self.results = [UnitRefreshResult.from_json(o) for o in results or []]
+
+
+
 class UnitResourceResult(Type):
     _toSchema = {'errorresult': 'ErrorResult', 'resource': 'resource'}
     _toPy = {'ErrorResult': 'errorresult', 'resource': 'resource'}
@@ -7332,8 +10047,8 @@ class UnitResources(Type):
     def __init__(self, entity=None, download_progress=None, resources=None, **unknown_fields):
         '''
         entity : Entity
-        download_progress : typing.Mapping<~KT, +VT_co>[str, int]
-        resources : typing.Sequence<+T_co>[~Resource]<~Resource>
+        download_progress : typing.Mapping[str, int]
+        resources : typing.Sequence[~Resource]
         '''
         self.entity = Entity.from_json(entity) if entity else None
         self.download_progress = download_progress
@@ -7347,7 +10062,7 @@ class UnitResourcesResult(Type):
     def __init__(self, errorresult=None, resources=None, **unknown_fields):
         '''
         errorresult : ErrorResult
-        resources : typing.Sequence<+T_co>[~UnitResourceResult]<~UnitResourceResult>
+        resources : typing.Sequence[~UnitResourceResult]
         '''
         self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
         self.resources = [UnitResourceResult.from_json(o) for o in resources or []]
@@ -7374,9 +10089,9 @@ class UnitStatus(Type):
         charm : str
         leader : bool
         machine : str
-        opened_ports : typing.Sequence<+T_co>[str]
+        opened_ports : typing.Sequence[str]
         public_address : str
-        subordinates : typing.Mapping<~KT, +VT_co>[str, ~UnitStatus]<~UnitStatus>
+        subordinates : typing.Mapping[str, ~UnitStatus]
         workload_status : DetailedStatus
         workload_version : str
         '''
@@ -7397,23 +10112,88 @@ class UnitsNetworkConfig(Type):
     _toPy = {'args': 'args'}
     def __init__(self, args=None, **unknown_fields):
         '''
-        args : typing.Sequence<+T_co>[~UnitNetworkConfig]<~UnitNetworkConfig>
+        args : typing.Sequence[~UnitNetworkConfig]
         '''
         self.args = [UnitNetworkConfig.from_json(o) for o in args or []]
 
 
 
+class UnitsResolved(Type):
+    _toSchema = {'all_': 'all', 'retry': 'retry', 'tags': 'tags'}
+    _toPy = {'all': 'all_', 'retry': 'retry', 'tags': 'tags'}
+    def __init__(self, all_=None, retry=None, tags=None, **unknown_fields):
+        '''
+        all_ : bool
+        retry : bool
+        tags : Entities
+        '''
+        self.all_ = all_
+        self.retry = retry
+        self.tags = Entities.from_json(tags) if tags else None
+
+
+
 class UnsetModelDefaults(Type):
     _toSchema = {'keys': 'keys'}
     _toPy = {'keys': 'keys'}
     def __init__(self, keys=None, **unknown_fields):
         '''
-        keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
+        keys : typing.Sequence[~ModelUnsetKeys]
         '''
         self.keys = [ModelUnsetKeys.from_json(o) for o in keys or []]
 
 
 
+class UpdateApplicationServiceArg(Type):
+    _toSchema = {'addresses': 'addresses', 'application_tag': 'application-tag', 'provider_id': 'provider-id'}
+    _toPy = {'addresses': 'addresses', 'application-tag': 'application_tag', 'provider-id': 'provider_id'}
+    def __init__(self, addresses=None, application_tag=None, provider_id=None, **unknown_fields):
+        '''
+        addresses : typing.Sequence[~Address]
+        application_tag : str
+        provider_id : str
+        '''
+        self.addresses = [Address.from_json(o) for o in addresses or []]
+        self.application_tag = application_tag
+        self.provider_id = provider_id
+
+
+
+class UpdateApplicationServiceArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~UpdateApplicationServiceArg]
+        '''
+        self.args = [UpdateApplicationServiceArg.from_json(o) for o in args or []]
+
+
+
+class UpdateApplicationUnitArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~UpdateApplicationUnits]
+        '''
+        self.args = [UpdateApplicationUnits.from_json(o) for o in args or []]
+
+
+
+class UpdateApplicationUnits(Type):
+    _toSchema = {'application_tag': 'application-tag', 'units': 'units'}
+    _toPy = {'application-tag': 'application_tag', 'units': 'units'}
+    def __init__(self, application_tag=None, units=None, **unknown_fields):
+        '''
+        application_tag : str
+        units : typing.Sequence[~ApplicationUnitParams]
+        '''
+        self.application_tag = application_tag
+        self.units = [ApplicationUnitParams.from_json(o) for o in units or []]
+
+
+
 class UpdateBehavior(Type):
     _toSchema = {'enable_os_refresh_update': 'enable-os-refresh-update', 'enable_os_upgrade': 'enable-os-upgrade'}
     _toPy = {'enable-os-refresh-update': 'enable_os_refresh_update', 'enable-os-upgrade': 'enable_os_upgrade'}
@@ -7445,12 +10225,92 @@ class UpdateCloudCredentials(Type):
     _toPy = {'credentials': 'credentials'}
     def __init__(self, credentials=None, **unknown_fields):
         '''
-        credentials : typing.Sequence<+T_co>[~UpdateCloudCredential]<~UpdateCloudCredential>
+        credentials : typing.Sequence[~UpdateCloudCredential]
         '''
         self.credentials = [UpdateCloudCredential.from_json(o) for o in credentials or []]
 
 
 
+class UpdateCredentialArgs(Type):
+    _toSchema = {'credentials': 'credentials', 'force': 'force'}
+    _toPy = {'credentials': 'credentials', 'force': 'force'}
+    def __init__(self, credentials=None, force=None, **unknown_fields):
+        '''
+        credentials : typing.Sequence[~TaggedCredential]
+        force : bool
+        '''
+        self.credentials = [TaggedCredential.from_json(o) for o in credentials or []]
+        self.force = force
+
+
+
+class UpdateCredentialModelResult(Type):
+    _toSchema = {'errors': 'errors', 'name': 'name', 'uuid': 'uuid'}
+    _toPy = {'errors': 'errors', 'name': 'name', 'uuid': 'uuid'}
+    def __init__(self, errors=None, name=None, uuid=None, **unknown_fields):
+        '''
+        errors : typing.Sequence[~ErrorResult]
+        name : str
+        uuid : str
+        '''
+        self.errors = [ErrorResult.from_json(o) for o in errors or []]
+        self.name = name
+        self.uuid = uuid
+
+
+
+class UpdateCredentialResult(Type):
+    _toSchema = {'error': 'error', 'models': 'models', 'tag': 'tag'}
+    _toPy = {'error': 'error', 'models': 'models', 'tag': 'tag'}
+    def __init__(self, error=None, models=None, tag=None, **unknown_fields):
+        '''
+        error : Error
+        models : typing.Sequence[~UpdateCredentialModelResult]
+        tag : str
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.models = [UpdateCredentialModelResult.from_json(o) for o in models or []]
+        self.tag = tag
+
+
+
+class UpdateCredentialResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~UpdateCredentialResult]
+        '''
+        self.results = [UpdateCredentialResult.from_json(o) for o in results or []]
+
+
+
+class UpdateSeriesArg(Type):
+    _toSchema = {'force': 'force', 'series': 'series', 'tag': 'tag'}
+    _toPy = {'force': 'force', 'series': 'series', 'tag': 'tag'}
+    def __init__(self, force=None, series=None, tag=None, **unknown_fields):
+        '''
+        force : bool
+        series : str
+        tag : Entity
+        '''
+        self.force = force
+        self.series = series
+        self.tag = Entity.from_json(tag) if tag else None
+
+
+
+class UpdateSeriesArgs(Type):
+    _toSchema = {'args': 'args'}
+    _toPy = {'args': 'args'}
+    def __init__(self, args=None, **unknown_fields):
+        '''
+        args : typing.Sequence[~UpdateSeriesArg]
+        '''
+        self.args = [UpdateSeriesArg.from_json(o) for o in args or []]
+
+
+
 class UpgradeMongoParams(Type):
     _toSchema = {'target': 'target'}
     _toPy = {'target': 'target'}
@@ -7462,6 +10322,117 @@ class UpgradeMongoParams(Type):
 
 
 
+class UpgradeSeriesNotificationParam(Type):
+    _toSchema = {'entity': 'entity', 'watcher_id': 'watcher-id'}
+    _toPy = {'entity': 'entity', 'watcher-id': 'watcher_id'}
+    def __init__(self, entity=None, watcher_id=None, **unknown_fields):
+        '''
+        entity : Entity
+        watcher_id : str
+        '''
+        self.entity = Entity.from_json(entity) if entity else None
+        self.watcher_id = watcher_id
+
+
+
+class UpgradeSeriesNotificationParams(Type):
+    _toSchema = {'params': 'params'}
+    _toPy = {'params': 'params'}
+    def __init__(self, params=None, **unknown_fields):
+        '''
+        params : typing.Sequence[~UpgradeSeriesNotificationParam]
+        '''
+        self.params = [UpgradeSeriesNotificationParam.from_json(o) for o in params or []]
+
+
+
+class UpgradeSeriesStartUnitCompletionParam(Type):
+    _toSchema = {'entities': 'entities', 'message': 'message'}
+    _toPy = {'entities': 'entities', 'message': 'message'}
+    def __init__(self, entities=None, message=None, **unknown_fields):
+        '''
+        entities : typing.Sequence[~Entity]
+        message : str
+        '''
+        self.entities = [Entity.from_json(o) for o in entities or []]
+        self.message = message
+
+
+
+class UpgradeSeriesStatusParam(Type):
+    _toSchema = {'entity': 'entity', 'message': 'message', 'status': 'status'}
+    _toPy = {'entity': 'entity', 'message': 'message', 'status': 'status'}
+    def __init__(self, entity=None, message=None, status=None, **unknown_fields):
+        '''
+        entity : Entity
+        message : str
+        status : str
+        '''
+        self.entity = Entity.from_json(entity) if entity else None
+        self.message = message
+        self.status = status
+
+
+
+class UpgradeSeriesStatusParams(Type):
+    _toSchema = {'params': 'params'}
+    _toPy = {'params': 'params'}
+    def __init__(self, params=None, **unknown_fields):
+        '''
+        params : typing.Sequence[~UpgradeSeriesStatusParam]
+        '''
+        self.params = [UpgradeSeriesStatusParam.from_json(o) for o in params or []]
+
+
+
+class UpgradeSeriesStatusResult(Type):
+    _toSchema = {'error': 'error', 'status': 'status'}
+    _toPy = {'error': 'error', 'status': 'status'}
+    def __init__(self, error=None, status=None, **unknown_fields):
+        '''
+        error : Error
+        status : str
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.status = status
+
+
+
+class UpgradeSeriesStatusResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~UpgradeSeriesStatusResult]
+        '''
+        self.results = [UpgradeSeriesStatusResult.from_json(o) for o in results or []]
+
+
+
+class UpgradeSeriesUnitsResult(Type):
+    _toSchema = {'error': 'error', 'unit_names': 'unit-names'}
+    _toPy = {'error': 'error', 'unit-names': 'unit_names'}
+    def __init__(self, error=None, unit_names=None, **unknown_fields):
+        '''
+        error : Error
+        unit_names : typing.Sequence[str]
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.unit_names = unit_names
+
+
+
+class UpgradeSeriesUnitsResults(Type):
+    _toSchema = {'results': 'Results'}
+    _toPy = {'Results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~UpgradeSeriesUnitsResult]
+        '''
+        self.results = [UpgradeSeriesUnitsResult.from_json(o) for o in results or []]
+
+
+
 class UserAccess(Type):
     _toSchema = {'access': 'access', 'user_tag': 'user-tag'}
     _toPy = {'access': 'access', 'user-tag': 'user_tag'}
@@ -7493,7 +10464,7 @@ class UserAccessResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~UserAccessResult]<~UserAccessResult>
+        results : typing.Sequence[~UserAccessResult]
         '''
         self.results = [UserAccessResult.from_json(o) for o in results or []]
 
@@ -7517,7 +10488,7 @@ class UserClouds(Type):
     _toPy = {'user-clouds': 'user_clouds'}
     def __init__(self, user_clouds=None, **unknown_fields):
         '''
-        user_clouds : typing.Sequence<+T_co>[~UserCloud]<~UserCloud>
+        user_clouds : typing.Sequence[~UserCloud]
         '''
         self.user_clouds = [UserCloud.from_json(o) for o in user_clouds or []]
 
@@ -7551,7 +10522,7 @@ class UserInfoRequest(Type):
     _toPy = {'entities': 'entities', 'include-disabled': 'include_disabled'}
     def __init__(self, entities=None, include_disabled=None, **unknown_fields):
         '''
-        entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+        entities : typing.Sequence[~Entity]
         include_disabled : bool
         '''
         self.entities = [Entity.from_json(o) for o in entities or []]
@@ -7577,7 +10548,7 @@ class UserInfoResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~UserInfoResult]<~UserInfoResult>
+        results : typing.Sequence[~UserInfoResult]
         '''
         self.results = [UserInfoResult.from_json(o) for o in results or []]
 
@@ -7601,7 +10572,7 @@ class UserModelList(Type):
     _toPy = {'user-models': 'user_models'}
     def __init__(self, user_models=None, **unknown_fields):
         '''
-        user_models : typing.Sequence<+T_co>[~UserModel]<~UserModel>
+        user_models : typing.Sequence[~UserModel]
         '''
         self.user_models = [UserModel.from_json(o) for o in user_models or []]
 
@@ -7619,8 +10590,8 @@ class Value(Type):
         instance_type : str
         mem : int
         root_disk : int
-        spaces : typing.Sequence<+T_co>[str]
-        tags : typing.Sequence<+T_co>[str]
+        spaces : typing.Sequence[str]
+        tags : typing.Sequence[str]
         virt_type : str
         '''
         self.arch = arch
@@ -7665,7 +10636,7 @@ class VersionResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~VersionResult]<~VersionResult>
+        results : typing.Sequence[~VersionResult]
         '''
         self.results = [VersionResult.from_json(o) for o in results or []]
 
@@ -7768,12 +10739,79 @@ class VolumeAttachmentParamsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~VolumeAttachmentParamsResult]<~VolumeAttachmentParamsResult>
+        results : typing.Sequence[~VolumeAttachmentParamsResult]
         '''
         self.results = [VolumeAttachmentParamsResult.from_json(o) for o in results or []]
 
 
 
+class VolumeAttachmentPlan(Type):
+    _toSchema = {'block_device': 'block-device', 'life': 'life', 'machine_tag': 'machine-tag', 'plan_info': 'plan-info', 'volume_tag': 'volume-tag'}
+    _toPy = {'block-device': 'block_device', 'life': 'life', 'machine-tag': 'machine_tag', 'plan-info': 'plan_info', 'volume-tag': 'volume_tag'}
+    def __init__(self, block_device=None, life=None, machine_tag=None, plan_info=None, volume_tag=None, **unknown_fields):
+        '''
+        block_device : BlockDevice
+        life : str
+        machine_tag : str
+        plan_info : VolumeAttachmentPlanInfo
+        volume_tag : str
+        '''
+        self.block_device = BlockDevice.from_json(block_device) if block_device else None
+        self.life = life
+        self.machine_tag = machine_tag
+        self.plan_info = VolumeAttachmentPlanInfo.from_json(plan_info) if plan_info else None
+        self.volume_tag = volume_tag
+
+
+
+class VolumeAttachmentPlanInfo(Type):
+    _toSchema = {'device_attributes': 'device-attributes', 'device_type': 'device-type'}
+    _toPy = {'device-attributes': 'device_attributes', 'device-type': 'device_type'}
+    def __init__(self, device_attributes=None, device_type=None, **unknown_fields):
+        '''
+        device_attributes : typing.Mapping[str, str]
+        device_type : str
+        '''
+        self.device_attributes = device_attributes
+        self.device_type = device_type
+
+
+
+class VolumeAttachmentPlanResult(Type):
+    _toSchema = {'error': 'error', 'result': 'result'}
+    _toPy = {'error': 'error', 'result': 'result'}
+    def __init__(self, error=None, result=None, **unknown_fields):
+        '''
+        error : Error
+        result : VolumeAttachmentPlan
+        '''
+        self.error = Error.from_json(error) if error else None
+        self.result = VolumeAttachmentPlan.from_json(result) if result else None
+
+
+
+class VolumeAttachmentPlanResults(Type):
+    _toSchema = {'results': 'results'}
+    _toPy = {'results': 'results'}
+    def __init__(self, results=None, **unknown_fields):
+        '''
+        results : typing.Sequence[~VolumeAttachmentPlanResult]
+        '''
+        self.results = [VolumeAttachmentPlanResult.from_json(o) for o in results or []]
+
+
+
+class VolumeAttachmentPlans(Type):
+    _toSchema = {'volume_plans': 'volume-plans'}
+    _toPy = {'volume-plans': 'volume_plans'}
+    def __init__(self, volume_plans=None, **unknown_fields):
+        '''
+        volume_plans : typing.Sequence[~VolumeAttachmentPlan]
+        '''
+        self.volume_plans = [VolumeAttachmentPlan.from_json(o) for o in volume_plans or []]
+
+
+
 class VolumeAttachmentResult(Type):
     _toSchema = {'error': 'error', 'result': 'result'}
     _toPy = {'error': 'error', 'result': 'result'}
@@ -7792,7 +10830,7 @@ class VolumeAttachmentResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~VolumeAttachmentResult]<~VolumeAttachmentResult>
+        results : typing.Sequence[~VolumeAttachmentResult]
         '''
         self.results = [VolumeAttachmentResult.from_json(o) for o in results or []]
 
@@ -7803,7 +10841,7 @@ class VolumeAttachments(Type):
     _toPy = {'volume-attachments': 'volume_attachments'}
     def __init__(self, volume_attachments=None, **unknown_fields):
         '''
-        volume_attachments : typing.Sequence<+T_co>[~VolumeAttachment]<~VolumeAttachment>
+        volume_attachments : typing.Sequence[~VolumeAttachment]
         '''
         self.volume_attachments = [VolumeAttachment.from_json(o) for o in volume_attachments or []]
 
@@ -7815,7 +10853,7 @@ class VolumeDetails(Type):
     def __init__(self, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None, **unknown_fields):
         '''
         info : VolumeInfo
-        machine_attachments : typing.Mapping<~KT, +VT_co>[str, ~VolumeAttachmentInfo]<~VolumeAttachmentInfo>
+        machine_attachments : typing.Mapping[str, ~VolumeAttachmentInfo]
         status : EntityStatus
         storage : StorageDetails
         volume_tag : str
@@ -7834,7 +10872,7 @@ class VolumeDetailsListResult(Type):
     def __init__(self, error=None, result=None, **unknown_fields):
         '''
         error : Error
-        result : typing.Sequence<+T_co>[~VolumeDetails]<~VolumeDetails>
+        result : typing.Sequence[~VolumeDetails]
         '''
         self.error = Error.from_json(error) if error else None
         self.result = [VolumeDetails.from_json(o) for o in result or []]
@@ -7846,7 +10884,7 @@ class VolumeDetailsListResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~VolumeDetailsListResult]<~VolumeDetailsListResult>
+        results : typing.Sequence[~VolumeDetailsListResult]
         '''
         self.results = [VolumeDetailsListResult.from_json(o) for o in results or []]
 
@@ -7857,7 +10895,7 @@ class VolumeFilter(Type):
     _toPy = {'machines': 'machines'}
     def __init__(self, machines=None, **unknown_fields):
         '''
-        machines : typing.Sequence<+T_co>[str]
+        machines : typing.Sequence[str]
         '''
         self.machines = machines
 
@@ -7868,7 +10906,7 @@ class VolumeFilters(Type):
     _toPy = {'filters': 'filters'}
     def __init__(self, filters=None, **unknown_fields):
         '''
-        filters : typing.Sequence<+T_co>[~VolumeFilter]<~VolumeFilter>
+        filters : typing.Sequence[~VolumeFilter]
         '''
         self.filters = [VolumeFilter.from_json(o) for o in filters or []]
 
@@ -7897,10 +10935,10 @@ class VolumeParams(Type):
     def __init__(self, attachment=None, attributes=None, provider=None, size=None, tags=None, volume_tag=None, **unknown_fields):
         '''
         attachment : VolumeAttachmentParams
-        attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+        attributes : typing.Mapping[str, typing.Any]
         provider : str
         size : int
-        tags : typing.Mapping<~KT, +VT_co>[str, str]
+        tags : typing.Mapping[str, str]
         volume_tag : str
         '''
         self.attachment = VolumeAttachmentParams.from_json(attachment) if attachment else None
@@ -7930,7 +10968,7 @@ class VolumeParamsResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~VolumeParamsResult]<~VolumeParamsResult>
+        results : typing.Sequence[~VolumeParamsResult]
         '''
         self.results = [VolumeParamsResult.from_json(o) for o in results or []]
 
@@ -7954,7 +10992,7 @@ class VolumeResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~VolumeResult]<~VolumeResult>
+        results : typing.Sequence[~VolumeResult]
         '''
         self.results = [VolumeResult.from_json(o) for o in results or []]
 
@@ -7965,7 +11003,7 @@ class Volumes(Type):
     _toPy = {'volumes': 'volumes'}
     def __init__(self, volumes=None, **unknown_fields):
         '''
-        volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
+        volumes : typing.Sequence[~Volume]
         '''
         self.volumes = [Volume.from_json(o) for o in volumes or []]
 
@@ -7989,7 +11027,7 @@ class WatchContainers(Type):
     _toPy = {'params': 'params'}
     def __init__(self, params=None, **unknown_fields):
         '''
-        params : typing.Sequence<+T_co>[~WatchContainer]<~WatchContainer>
+        params : typing.Sequence[~WatchContainer]
         '''
         self.params = [WatchContainer.from_json(o) for o in params or []]
 
@@ -8015,6 +11053,6 @@ class ZoneResults(Type):
     _toPy = {'results': 'results'}
     def __init__(self, results=None, **unknown_fields):
         '''
-        results : typing.Sequence<+T_co>[~ZoneResult]<~ZoneResult>
+        results : typing.Sequence[~ZoneResult]
         '''
         self.results = [ZoneResult.from_json(o) for o in results or []]