+class StorageDetailsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : StorageDetails
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = StorageDetails.from_json(result) if result else None
+
+
+class StorageDetailsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~StorageDetailsResult]<~StorageDetailsResult>
+ '''
+ self.results = [StorageDetailsResult.from_json(o) for o in results or []]
+
+
+class StorageFilter(Type):
+ _toSchema = {}
+ _toPy = {}
+ def __init__(self):
+ '''
+
+ '''
+ pass
+
+
+class StorageFilters(Type):
+ _toSchema = {'filters': 'filters'}
+ _toPy = {'filters': 'filters'}
+ def __init__(self, filters=None):
+ '''
+ filters : typing.Sequence<+T_co>[~StorageFilter]<~StorageFilter>
+ '''
+ self.filters = [StorageFilter.from_json(o) for o in filters or []]
+
+
+class StoragePool(Type):
+ _toSchema = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
+ _toPy = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
+ def __init__(self, attrs=None, name=None, provider=None):
+ '''
+ attrs : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ name : str
+ provider : str
+ '''
+ self.attrs = attrs
+ self.name = name
+ self.provider = provider
+
+
+class StoragePoolFilter(Type):
+ _toSchema = {'names': 'names', 'providers': 'providers'}
+ _toPy = {'names': 'names', 'providers': 'providers'}
+ def __init__(self, names=None, providers=None):
+ '''
+ names : typing.Sequence<+T_co>[str]
+ providers : typing.Sequence<+T_co>[str]
+ '''
+ self.names = names
+ self.providers = providers
+
+
+class StoragePoolFilters(Type):
+ _toSchema = {'filters': 'filters'}
+ _toPy = {'filters': 'filters'}
+ def __init__(self, filters=None):
+ '''
+ filters : typing.Sequence<+T_co>[~StoragePoolFilter]<~StoragePoolFilter>
+ '''
+ self.filters = [StoragePoolFilter.from_json(o) for o in filters or []]
+
+
+class StoragePoolsResult(Type):
+ _toSchema = {'error': 'error', 'storage_pools': 'storage-pools'}
+ _toPy = {'error': 'error', 'storage-pools': 'storage_pools'}
+ def __init__(self, error=None, storage_pools=None):
+ '''
+ error : Error
+ storage_pools : typing.Sequence<+T_co>[~StoragePool]<~StoragePool>
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.storage_pools = [StoragePool.from_json(o) for o in storage_pools or []]
+
+
+class StoragePoolsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~StoragePoolsResult]<~StoragePoolsResult>
+ '''
+ self.results = [StoragePoolsResult.from_json(o) for o in results or []]
+
+
+class StoragesAddParams(Type):
+ _toSchema = {'storages': 'storages'}
+ _toPy = {'storages': 'storages'}
+ def __init__(self, storages=None):
+ '''
+ storages : typing.Sequence<+T_co>[~StorageAddParams]<~StorageAddParams>
+ '''
+ self.storages = [StorageAddParams.from_json(o) for o in storages or []]
+
+
+class VolumeDetails(Type):
+ _toSchema = {'info': 'info', 'machine_attachments': 'machine-attachments', 'status': 'status', 'storage': 'storage', 'volume_tag': 'volume-tag'}
+ _toPy = {'info': 'info', 'machine-attachments': 'machine_attachments', 'status': 'status', 'storage': 'storage', 'volume-tag': 'volume_tag'}
+ def __init__(self, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None):
+ '''
+ info : VolumeInfo
+ machine_attachments : typing.Mapping<~KT, +VT_co>[str, ~VolumeAttachmentInfo]<~VolumeAttachmentInfo>
+ status : EntityStatus
+ storage : StorageDetails
+ volume_tag : str
+ '''
+ self.info = VolumeInfo.from_json(info) if info else None
+ self.machine_attachments = machine_attachments
+ self.status = EntityStatus.from_json(status) if status else None
+ self.storage = StorageDetails.from_json(storage) if storage else None
+ self.volume_tag = volume_tag
+
+
+class VolumeDetailsListResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : typing.Sequence<+T_co>[~VolumeDetails]<~VolumeDetails>
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = [VolumeDetails.from_json(o) for o in result or []]
+
+
+class VolumeDetailsListResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~VolumeDetailsListResult]<~VolumeDetailsListResult>
+ '''
+ self.results = [VolumeDetailsListResult.from_json(o) for o in results or []]
+
+
+class VolumeFilter(Type):
+ _toSchema = {'machines': 'machines'}
+ _toPy = {'machines': 'machines'}
+ def __init__(self, machines=None):
+ '''
+ machines : typing.Sequence<+T_co>[str]
+ '''
+ self.machines = machines
+
+
+class VolumeFilters(Type):
+ _toSchema = {'filters': 'filters'}
+ _toPy = {'filters': 'filters'}
+ def __init__(self, filters=None):
+ '''
+ filters : typing.Sequence<+T_co>[~VolumeFilter]<~VolumeFilter>
+ '''
+ self.filters = [VolumeFilter.from_json(o) for o in filters or []]
+
+
+class BlockDeviceResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : BlockDevice
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = BlockDevice.from_json(result) if result else None
+
+
+class BlockDeviceResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~BlockDeviceResult]<~BlockDeviceResult>
+ '''
+ self.results = [BlockDeviceResult.from_json(o) for o in results 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'}
+ def __init__(self, filesystem_tag=None, info=None, volume_tag=None):
+ '''
+ filesystem_tag : str
+ info : FilesystemInfo
+ volume_tag : str
+ '''
+ self.filesystem_tag = filesystem_tag
+ self.info = FilesystemInfo.from_json(info) if info else None
+ self.volume_tag = volume_tag
+
+
+class FilesystemAttachment(Type):
+ _toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'machine_tag': 'machine-tag'}
+ _toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'machine-tag': 'machine_tag'}
+ def __init__(self, filesystem_tag=None, info=None, machine_tag=None):
+ '''
+ filesystem_tag : str
+ info : FilesystemAttachmentInfo
+ machine_tag : str
+ '''
+ self.filesystem_tag = filesystem_tag
+ self.info = FilesystemAttachmentInfo.from_json(info) if info else None
+ self.machine_tag = machine_tag
+
+
+class FilesystemAttachmentParams(Type):
+ _toSchema = {'filesystem_id': 'filesystem-id', 'filesystem_tag': 'filesystem-tag', 'instance_id': 'instance-id', 'machine_tag': 'machine-tag', 'mount_point': 'mount-point', 'provider': 'provider', 'read_only': 'read-only'}
+ _toPy = {'filesystem-id': 'filesystem_id', 'filesystem-tag': 'filesystem_tag', 'instance-id': 'instance_id', 'machine-tag': 'machine_tag', 'mount-point': 'mount_point', 'provider': 'provider', 'read-only': 'read_only'}
+ def __init__(self, filesystem_id=None, filesystem_tag=None, instance_id=None, machine_tag=None, mount_point=None, provider=None, read_only=None):
+ '''
+ filesystem_id : str
+ filesystem_tag : str
+ instance_id : str
+ machine_tag : str
+ mount_point : str
+ provider : str
+ read_only : bool
+ '''
+ self.filesystem_id = filesystem_id
+ self.filesystem_tag = filesystem_tag
+ self.instance_id = instance_id
+ self.machine_tag = machine_tag
+ self.mount_point = mount_point
+ self.provider = provider
+ self.read_only = read_only
+
+
+class FilesystemAttachmentParamsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : FilesystemAttachmentParams
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = FilesystemAttachmentParams.from_json(result) if result else None
+
+
+class FilesystemAttachmentParamsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~FilesystemAttachmentParamsResult]<~FilesystemAttachmentParamsResult>
+ '''
+ self.results = [FilesystemAttachmentParamsResult.from_json(o) for o in results or []]
+
+
+class FilesystemAttachmentResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : FilesystemAttachment
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = FilesystemAttachment.from_json(result) if result else None
+
+
+class FilesystemAttachmentResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~FilesystemAttachmentResult]<~FilesystemAttachmentResult>
+ '''
+ self.results = [FilesystemAttachmentResult.from_json(o) for o in results or []]
+
+
+class FilesystemAttachments(Type):
+ _toSchema = {'filesystem_attachments': 'filesystem-attachments'}
+ _toPy = {'filesystem-attachments': 'filesystem_attachments'}
+ def __init__(self, filesystem_attachments=None):
+ '''
+ filesystem_attachments : typing.Sequence<+T_co>[~FilesystemAttachment]<~FilesystemAttachment>
+ '''
+ self.filesystem_attachments = [FilesystemAttachment.from_json(o) for o in filesystem_attachments or []]
+
+
+class FilesystemParams(Type):
+ _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem_tag': 'filesystem-tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume_tag': 'volume-tag'}
+ _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'filesystem-tag': 'filesystem_tag', 'provider': 'provider', 'size': 'size', 'tags': 'tags', 'volume-tag': 'volume_tag'}
+ def __init__(self, attachment=None, attributes=None, filesystem_tag=None, provider=None, size=None, tags=None, volume_tag=None):
+ '''
+ attachment : FilesystemAttachmentParams
+ attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ filesystem_tag : str
+ provider : str
+ size : int
+ tags : typing.Mapping<~KT, +VT_co>[str, str]
+ volume_tag : str
+ '''
+ self.attachment = FilesystemAttachmentParams.from_json(attachment) if attachment else None
+ self.attributes = attributes
+ self.filesystem_tag = filesystem_tag
+ self.provider = provider
+ self.size = size
+ self.tags = tags
+ self.volume_tag = volume_tag
+
+
+class FilesystemParamsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : FilesystemParams
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = FilesystemParams.from_json(result) if result else None
+
+
+class FilesystemParamsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~FilesystemParamsResult]<~FilesystemParamsResult>
+ '''
+ self.results = [FilesystemParamsResult.from_json(o) for o in results or []]
+
+
+class FilesystemResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : Filesystem
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = Filesystem.from_json(result) if result else None
+
+
+class FilesystemResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~FilesystemResult]<~FilesystemResult>
+ '''
+ self.results = [FilesystemResult.from_json(o) for o in results or []]
+
+
+class Filesystems(Type):
+ _toSchema = {'filesystems': 'filesystems'}
+ _toPy = {'filesystems': 'filesystems'}
+ def __init__(self, filesystems=None):
+ '''
+ filesystems : typing.Sequence<+T_co>[~Filesystem]<~Filesystem>
+ '''
+ self.filesystems = [Filesystem.from_json(o) for o in filesystems or []]
+
+
+class MachineStorageIds(Type):
+ _toSchema = {'ids': 'ids'}
+ _toPy = {'ids': 'ids'}
+ def __init__(self, ids=None):
+ '''
+ ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
+ '''
+ self.ids = [MachineStorageId.from_json(o) for o in ids or []]
+
+
+class MachineStorageIdsWatchResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
+ '''
+ self.results = [MachineStorageIdsWatchResult.from_json(o) for o in results or []]
+
+
+class VolumeAttachment(Type):
+ _toSchema = {'info': 'info', 'machine_tag': 'machine-tag', 'volume_tag': 'volume-tag'}
+ _toPy = {'info': 'info', 'machine-tag': 'machine_tag', 'volume-tag': 'volume_tag'}
+ def __init__(self, info=None, machine_tag=None, volume_tag=None):
+ '''
+ info : VolumeAttachmentInfo
+ machine_tag : str
+ volume_tag : str
+ '''
+ self.info = VolumeAttachmentInfo.from_json(info) if info else None
+ self.machine_tag = machine_tag
+ self.volume_tag = volume_tag
+
+
+class VolumeAttachmentParamsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : VolumeAttachmentParams
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = VolumeAttachmentParams.from_json(result) if result else None
+
+
+class VolumeAttachmentParamsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~VolumeAttachmentParamsResult]<~VolumeAttachmentParamsResult>
+ '''
+ self.results = [VolumeAttachmentParamsResult.from_json(o) for o in results or []]
+
+
+class VolumeAttachmentResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : VolumeAttachment
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = VolumeAttachment.from_json(result) if result else None
+
+
+class VolumeAttachmentResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~VolumeAttachmentResult]<~VolumeAttachmentResult>
+ '''
+ self.results = [VolumeAttachmentResult.from_json(o) for o in results or []]
+
+
+class VolumeAttachments(Type):
+ _toSchema = {'volume_attachments': 'volume-attachments'}
+ _toPy = {'volume-attachments': 'volume_attachments'}
+ def __init__(self, volume_attachments=None):
+ '''
+ volume_attachments : typing.Sequence<+T_co>[~VolumeAttachment]<~VolumeAttachment>
+ '''
+ self.volume_attachments = [VolumeAttachment.from_json(o) for o in volume_attachments or []]
+
+
+class VolumeParamsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : VolumeParams
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = VolumeParams.from_json(result) if result else None
+
+
+class VolumeParamsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~VolumeParamsResult]<~VolumeParamsResult>
+ '''
+ self.results = [VolumeParamsResult.from_json(o) for o in results or []]
+
+
+class VolumeResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : Volume
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = Volume.from_json(result) if result else None
+
+
+class VolumeResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~VolumeResult]<~VolumeResult>
+ '''
+ self.results = [VolumeResult.from_json(o) for o in results or []]
+
+
+class Volumes(Type):
+ _toSchema = {'volumes': 'volumes'}
+ _toPy = {'volumes': 'volumes'}
+ def __init__(self, volumes=None):
+ '''
+ volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
+ '''
+ self.volumes = [Volume.from_json(o) for o in volumes or []]
+
+
+class SpaceResult(Type):
+ _toSchema = {'error': 'error', 'tag': 'tag'}
+ _toPy = {'error': 'error', 'tag': 'tag'}
+ def __init__(self, error=None, tag=None):
+ '''
+ error : Error
+ tag : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.tag = tag
+
+
+class SpaceResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~SpaceResult]<~SpaceResult>
+ '''
+ self.results = [SpaceResult.from_json(o) for o in results or []]
+
+
+class ZoneResult(Type):
+ _toSchema = {'available': 'available', 'error': 'error', 'name': 'name'}
+ _toPy = {'available': 'available', 'error': 'error', 'name': 'name'}
+ def __init__(self, available=None, error=None, name=None):
+ '''
+ available : bool
+ error : Error
+ name : str
+ '''
+ self.available = available
+ self.error = Error.from_json(error) if error else None
+ self.name = name
+
+
+class ZoneResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~ZoneResult]<~ZoneResult>
+ '''
+ self.results = [ZoneResult.from_json(o) for o in results or []]
+
+
+class UndertakerModelInfo(Type):
+ _toSchema = {'global_name': 'global-name', 'is_system': 'is-system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
+ _toPy = {'global-name': 'global_name', 'is-system': 'is_system', 'life': 'life', 'name': 'name', 'uuid': 'uuid'}
+ def __init__(self, global_name=None, is_system=None, life=None, name=None, uuid=None):
+ '''
+ global_name : str
+ is_system : bool
+ life : str
+ name : str
+ uuid : str
+ '''
+ self.global_name = global_name
+ self.is_system = is_system
+ self.life = life
+ self.name = name
+ self.uuid = uuid
+
+
+class UndertakerModelInfoResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : UndertakerModelInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = UndertakerModelInfo.from_json(result) if result else None
+
+
+class ApplicationStatusResult(Type):
+ _toSchema = {'application': 'application', 'error': 'error', 'units': 'units'}
+ _toPy = {'application': 'application', 'error': 'error', 'units': 'units'}
+ def __init__(self, application=None, error=None, units=None):
+ '''
+ application : StatusResult
+ error : Error
+ units : typing.Mapping<~KT, +VT_co>[str, ~StatusResult]<~StatusResult>
+ '''
+ self.application = StatusResult.from_json(application) if application else None
+ self.error = Error.from_json(error) if error else None
+ self.units = units
+
+
+class ApplicationStatusResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~ApplicationStatusResult]<~ApplicationStatusResult>
+ '''
+ self.results = [ApplicationStatusResult.from_json(o) for o in results or []]
+
+
+class CharmURLs(Type):
+ _toSchema = {'urls': 'urls'}
+ _toPy = {'urls': 'urls'}
+ def __init__(self, urls=None):
+ '''
+ urls : typing.Sequence<+T_co>[~CharmURL]<~CharmURL>
+ '''
+ self.urls = [CharmURL.from_json(o) for o in urls or []]
+
+
+class ConfigSettingsResult(Type):
+ _toSchema = {'error': 'error', 'settings': 'settings'}
+ _toPy = {'error': 'error', 'settings': 'settings'}
+ def __init__(self, error=None, settings=None):
+ '''
+ error : Error
+ settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.settings = settings
+
+
+class ConfigSettingsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~ConfigSettingsResult]<~ConfigSettingsResult>
+ '''
+ self.results = [ConfigSettingsResult.from_json(o) for o in results or []]
+
+
+class Endpoint(Type):
+ _toSchema = {'application_name': 'application-name', 'relation': 'relation'}
+ _toPy = {'application-name': 'application_name', 'relation': 'relation'}
+ def __init__(self, application_name=None, relation=None):
+ '''
+ application_name : str
+ relation : CharmRelation
+ '''
+ self.application_name = application_name
+ self.relation = CharmRelation.from_json(relation) if relation else None
+
+
+class EntitiesCharmURL(Type):
+ _toSchema = {'entities': 'entities'}
+ _toPy = {'entities': 'entities'}
+ def __init__(self, entities=None):
+ '''
+ entities : typing.Sequence<+T_co>[~EntityCharmURL]<~EntityCharmURL>
+ '''
+ self.entities = [EntityCharmURL.from_json(o) for o in entities or []]
+
+
+class EntitiesPortRanges(Type):
+ _toSchema = {'entities': 'entities'}
+ _toPy = {'entities': 'entities'}
+ def __init__(self, entities=None):
+ '''
+ entities : typing.Sequence<+T_co>[~EntityPortRange]<~EntityPortRange>
+ '''
+ self.entities = [EntityPortRange.from_json(o) for o in entities or []]
+
+
+class EntityCharmURL(Type):
+ _toSchema = {'charm_url': 'charm-url', 'tag': 'tag'}
+ _toPy = {'charm-url': 'charm_url', 'tag': 'tag'}
+ def __init__(self, charm_url=None, tag=None):
+ '''
+ charm_url : str
+ tag : str
+ '''
+ self.charm_url = charm_url
+ self.tag = tag
+
+
+class EntityPortRange(Type):
+ _toSchema = {'from_port': 'from-port', 'protocol': 'protocol', 'tag': 'tag', 'to_port': 'to-port'}
+ _toPy = {'from-port': 'from_port', 'protocol': 'protocol', 'tag': 'tag', 'to-port': 'to_port'}
+ def __init__(self, from_port=None, protocol=None, tag=None, to_port=None):
+ '''
+ from_port : int
+ protocol : str
+ tag : str
+ to_port : int
+ '''
+ self.from_port = from_port
+ self.protocol = protocol
+ self.tag = tag
+ self.to_port = to_port
+
+
+class EntityWorkloadVersion(Type):
+ _toSchema = {'tag': 'tag', 'workload_version': 'workload-version'}
+ _toPy = {'tag': 'tag', 'workload-version': 'workload_version'}
+ def __init__(self, tag=None, workload_version=None):
+ '''
+ tag : str
+ workload_version : str
+ '''
+ self.tag = tag
+ self.workload_version = workload_version
+
+
+class EntityWorkloadVersions(Type):
+ _toSchema = {'entities': 'entities'}
+ _toPy = {'entities': 'entities'}
+ def __init__(self, entities=None):
+ '''
+ entities : typing.Sequence<+T_co>[~EntityWorkloadVersion]<~EntityWorkloadVersion>
+ '''
+ self.entities = [EntityWorkloadVersion.from_json(o) for o in entities or []]
+
+
+class GetLeadershipSettingsBulkResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~GetLeadershipSettingsResult]<~GetLeadershipSettingsResult>
+ '''
+ self.results = [GetLeadershipSettingsResult.from_json(o) for o in results or []]
+
+
+class GetLeadershipSettingsResult(Type):
+ _toSchema = {'error': 'error', 'settings': 'settings'}
+ _toPy = {'error': 'error', 'settings': 'settings'}
+ def __init__(self, error=None, settings=None):
+ '''
+ error : Error
+ settings : typing.Mapping<~KT, +VT_co>[str, str]
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.settings = settings
+
+
+class IntResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : int
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = result
+
+
+class IntResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~IntResult]<~IntResult>
+ '''
+ self.results = [IntResult.from_json(o) for o in results or []]
+
+
+class MergeLeadershipSettingsBulkParams(Type):
+ _toSchema = {'params': 'params'}
+ _toPy = {'params': 'params'}
+ def __init__(self, params=None):
+ '''
+ params : typing.Sequence<+T_co>[~MergeLeadershipSettingsParam]<~MergeLeadershipSettingsParam>
+ '''
+ self.params = [MergeLeadershipSettingsParam.from_json(o) for o in params or []]
+
+
+class MergeLeadershipSettingsParam(Type):
+ _toSchema = {'application_tag': 'application-tag', 'settings': 'settings'}
+ _toPy = {'application-tag': 'application_tag', 'settings': 'settings'}
+ def __init__(self, application_tag=None, settings=None):
+ '''
+ application_tag : str
+ settings : typing.Mapping<~KT, +VT_co>[str, str]
+ '''
+ self.application_tag = application_tag
+ self.settings = settings
+
+
+class ModelResult(Type):
+ _toSchema = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
+ _toPy = {'error': 'error', 'name': 'name', 'uuid': 'uuid'}
+ def __init__(self, error=None, name=None, uuid=None):
+ '''
+ error : Error
+ name : str
+ uuid : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.name = name
+ self.uuid = uuid
+
+
+class RelationIds(Type):
+ _toSchema = {'relation_ids': 'relation-ids'}
+ _toPy = {'relation-ids': 'relation_ids'}
+ def __init__(self, relation_ids=None):
+ '''
+ relation_ids : typing.Sequence<+T_co>[int]
+ '''
+ self.relation_ids = relation_ids
+
+
+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'}
+ def __init__(self, endpoint=None, error=None, id_=None, key=None, life=None):
+ '''
+ endpoint : Endpoint
+ error : Error
+ id_ : int
+ key : str
+ life : str
+ '''
+ self.endpoint = Endpoint.from_json(endpoint) if endpoint else None
+ self.error = Error.from_json(error) if error else None
+ self.id_ = id_
+ self.key = key
+ self.life = life
+
+
+class RelationResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~RelationResult]<~RelationResult>
+ '''
+ self.results = [RelationResult.from_json(o) for o in results or []]
+
+
+class RelationUnit(Type):
+ _toSchema = {'relation': 'relation', 'unit': 'unit'}
+ _toPy = {'relation': 'relation', 'unit': 'unit'}
+ def __init__(self, relation=None, unit=None):
+ '''
+ relation : str
+ unit : str
+ '''
+ self.relation = relation
+ self.unit = unit
+
+
+class RelationUnitPair(Type):
+ _toSchema = {'local_unit': 'local-unit', 'relation': 'relation', 'remote_unit': 'remote-unit'}
+ _toPy = {'local-unit': 'local_unit', 'relation': 'relation', 'remote-unit': 'remote_unit'}
+ def __init__(self, local_unit=None, relation=None, remote_unit=None):
+ '''
+ local_unit : str
+ relation : str
+ remote_unit : str
+ '''
+ self.local_unit = local_unit
+ self.relation = relation
+ self.remote_unit = remote_unit
+
+
+class RelationUnitPairs(Type):
+ _toSchema = {'relation_unit_pairs': 'relation-unit-pairs'}
+ _toPy = {'relation-unit-pairs': 'relation_unit_pairs'}
+ def __init__(self, relation_unit_pairs=None):
+ '''
+ relation_unit_pairs : typing.Sequence<+T_co>[~RelationUnitPair]<~RelationUnitPair>
+ '''
+ self.relation_unit_pairs = [RelationUnitPair.from_json(o) for o in relation_unit_pairs or []]
+
+
+class RelationUnitSettings(Type):
+ _toSchema = {'relation': 'relation', 'settings': 'settings', 'unit': 'unit'}
+ _toPy = {'relation': 'relation', 'settings': 'settings', 'unit': 'unit'}
+ def __init__(self, relation=None, settings=None, unit=None):
+ '''
+ relation : str
+ settings : typing.Mapping<~KT, +VT_co>[str, str]
+ unit : str
+ '''
+ self.relation = relation
+ self.settings = settings
+ self.unit = unit
+
+
+class RelationUnits(Type):
+ _toSchema = {'relation_units': 'relation-units'}
+ _toPy = {'relation-units': 'relation_units'}
+ def __init__(self, relation_units=None):
+ '''
+ relation_units : typing.Sequence<+T_co>[~RelationUnit]<~RelationUnit>
+ '''
+ self.relation_units = [RelationUnit.from_json(o) for o in relation_units or []]
+
+
+class RelationUnitsSettings(Type):
+ _toSchema = {'relation_units': 'relation-units'}
+ _toPy = {'relation-units': 'relation_units'}
+ def __init__(self, relation_units=None):
+ '''
+ relation_units : typing.Sequence<+T_co>[~RelationUnitSettings]<~RelationUnitSettings>
+ '''
+ self.relation_units = [RelationUnitSettings.from_json(o) for o in relation_units or []]
+
+
+class RelationUnitsWatchResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~RelationUnitsWatchResult]<~RelationUnitsWatchResult>
+ '''
+ self.results = [RelationUnitsWatchResult.from_json(o) for o in results or []]
+
+
+class ResolvedModeResult(Type):
+ _toSchema = {'error': 'error', 'mode': 'mode'}
+ _toPy = {'error': 'error', 'mode': 'mode'}
+ def __init__(self, error=None, mode=None):
+ '''
+ error : Error
+ mode : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.mode = mode
+
+
+class ResolvedModeResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~ResolvedModeResult]<~ResolvedModeResult>
+ '''
+ self.results = [ResolvedModeResult.from_json(o) for o in results or []]
+
+
+class SettingsResult(Type):
+ _toSchema = {'error': 'error', 'settings': 'settings'}
+ _toPy = {'error': 'error', 'settings': 'settings'}
+ def __init__(self, error=None, settings=None):
+ '''
+ error : Error
+ settings : typing.Mapping<~KT, +VT_co>[str, str]
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.settings = settings
+
+
+class SettingsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~SettingsResult]<~SettingsResult>
+ '''
+ self.results = [SettingsResult.from_json(o) for o in results or []]
+
+
+class StorageAttachment(Type):
+ _toSchema = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner_tag': 'owner-tag', 'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
+ _toPy = {'kind': 'kind', 'life': 'life', 'location': 'location', 'owner-tag': 'owner_tag', 'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
+ def __init__(self, kind=None, life=None, location=None, owner_tag=None, storage_tag=None, unit_tag=None):
+ '''
+ kind : int
+ life : str
+ location : str
+ owner_tag : str
+ storage_tag : str
+ unit_tag : str
+ '''
+ self.kind = kind
+ self.life = life
+ self.location = location
+ self.owner_tag = owner_tag
+ self.storage_tag = storage_tag
+ self.unit_tag = unit_tag
+
+
+class StorageAttachmentId(Type):
+ _toSchema = {'storage_tag': 'storage-tag', 'unit_tag': 'unit-tag'}
+ _toPy = {'storage-tag': 'storage_tag', 'unit-tag': 'unit_tag'}
+ def __init__(self, storage_tag=None, unit_tag=None):
+ '''
+ storage_tag : str
+ unit_tag : str
+ '''
+ self.storage_tag = storage_tag
+ self.unit_tag = unit_tag
+
+
+class StorageAttachmentIds(Type):
+ _toSchema = {'ids': 'ids'}
+ _toPy = {'ids': 'ids'}
+ def __init__(self, ids=None):
+ '''
+ ids : typing.Sequence<+T_co>[~StorageAttachmentId]<~StorageAttachmentId>
+ '''
+ self.ids = [StorageAttachmentId.from_json(o) for o in ids or []]
+
+
+class StorageAttachmentIdsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : StorageAttachmentIds
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = StorageAttachmentIds.from_json(result) if result else None
+
+
+class StorageAttachmentIdsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~StorageAttachmentIdsResult]<~StorageAttachmentIdsResult>
+ '''
+ self.results = [StorageAttachmentIdsResult.from_json(o) for o in results or []]
+
+
+class StorageAttachmentResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : StorageAttachment
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = StorageAttachment.from_json(result) if result else None
+
+
+class StorageAttachmentResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~StorageAttachmentResult]<~StorageAttachmentResult>
+ '''
+ self.results = [StorageAttachmentResult.from_json(o) for o in results or []]
+
+
+class StringBoolResult(Type):
+ _toSchema = {'error': 'error', 'ok': 'ok', 'result': 'result'}
+ _toPy = {'error': 'error', 'ok': 'ok', 'result': 'result'}
+ def __init__(self, error=None, ok=None, result=None):
+ '''
+ error : Error
+ ok : bool
+ result : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.ok = ok
+ self.result = result
+
+
+class StringBoolResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~StringBoolResult]<~StringBoolResult>
+ '''
+ self.results = [StringBoolResult.from_json(o) for o in results or []]
+
+
+class UnitNetworkConfig(Type):
+ _toSchema = {'binding_name': 'binding-name', 'unit_tag': 'unit-tag'}
+ _toPy = {'binding-name': 'binding_name', 'unit-tag': 'unit_tag'}
+ def __init__(self, binding_name=None, unit_tag=None):
+ '''
+ binding_name : str
+ unit_tag : str
+ '''
+ self.binding_name = binding_name
+ self.unit_tag = unit_tag
+
+
+class UnitNetworkConfigResult(Type):
+ _toSchema = {'error': 'error', 'info': 'info'}
+ _toPy = {'error': 'error', 'info': 'info'}
+ def __init__(self, error=None, info=None):
+ '''
+ error : Error
+ info : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.info = [NetworkConfig.from_json(o) for o in info or []]
+
+
+class UnitNetworkConfigResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~UnitNetworkConfigResult]<~UnitNetworkConfigResult>
+ '''
+ self.results = [UnitNetworkConfigResult.from_json(o) for o in results or []]
+
+
+class UnitsNetworkConfig(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None):
+ '''
+ args : typing.Sequence<+T_co>[~UnitNetworkConfig]<~UnitNetworkConfig>
+ '''
+ self.args = [UnitNetworkConfig.from_json(o) for o in args or []]
+
+
+class EntitiesVersion(Type):
+ _toSchema = {'agent_tools': 'agent-tools'}
+ _toPy = {'agent-tools': 'agent_tools'}
+ def __init__(self, agent_tools=None):
+ '''
+ agent_tools : typing.Sequence<+T_co>[~EntityVersion]<~EntityVersion>
+ '''
+ self.agent_tools = [EntityVersion.from_json(o) for o in agent_tools or []]
+
+
+class EntityVersion(Type):
+ _toSchema = {'tag': 'tag', 'tools': 'tools'}
+ _toPy = {'tag': 'tag', 'tools': 'tools'}
+ def __init__(self, tag=None, tools=None):
+ '''
+ tag : str
+ tools : Version
+ '''
+ self.tag = tag
+ self.tools = Version.from_json(tools) if tools else None
+
+
+class Version(Type):
+ _toSchema = {'version': 'version'}
+ _toPy = {'version': 'version'}
+ def __init__(self, version=None):
+ '''
+ version : Binary
+ '''
+ self.version = Binary.from_json(version) if version else None
+
+
+class VersionResult(Type):
+ _toSchema = {'error': 'error', 'version': 'version'}
+ _toPy = {'error': 'error', 'version': 'version'}
+ def __init__(self, error=None, version=None):
+ '''
+ error : Error
+ version : Number
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.version = Number.from_json(version) if version else None
+
+
+class VersionResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~VersionResult]<~VersionResult>
+ '''
+ self.results = [VersionResult.from_json(o) for o in results or []]
+
+
+class AddUser(Type):
+ _toSchema = {'display_name': 'display-name', 'password': 'password', 'username': 'username'}
+ _toPy = {'display-name': 'display_name', 'password': 'password', 'username': 'username'}
+ def __init__(self, display_name=None, password=None, username=None):
+ '''
+ display_name : str
+ password : str
+ username : str
+ '''
+ self.display_name = display_name
+ self.password = password
+ self.username = username
+
+
+class AddUserResult(Type):
+ _toSchema = {'error': 'error', 'secret_key': 'secret-key', 'tag': 'tag'}
+ _toPy = {'error': 'error', 'secret-key': 'secret_key', 'tag': 'tag'}
+ def __init__(self, error=None, secret_key=None, tag=None):
+ '''
+ error : Error
+ secret_key : typing.Sequence<+T_co>[int]
+ tag : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.secret_key = secret_key
+ self.tag = tag
+
+
+class AddUserResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~AddUserResult]<~AddUserResult>
+ '''
+ self.results = [AddUserResult.from_json(o) for o in results or []]
+
+
+class AddUsers(Type):
+ _toSchema = {'users': 'users'}
+ _toPy = {'users': 'users'}
+ def __init__(self, users=None):
+ '''
+ users : typing.Sequence<+T_co>[~AddUser]<~AddUser>
+ '''
+ self.users = [AddUser.from_json(o) for o in users or []]
+
+
+class UserInfo(Type):
+ _toSchema = {'access': 'access', 'created_by': 'created-by', 'date_created': 'date-created', 'disabled': 'disabled', 'display_name': 'display-name', 'last_connection': 'last-connection', 'username': 'username'}
+ _toPy = {'access': 'access', 'created-by': 'created_by', 'date-created': 'date_created', 'disabled': 'disabled', 'display-name': 'display_name', 'last-connection': 'last_connection', 'username': 'username'}
+ def __init__(self, access=None, created_by=None, date_created=None, disabled=None, display_name=None, last_connection=None, username=None):
+ '''
+ access : str
+ created_by : str
+ date_created : str
+ disabled : bool
+ display_name : str
+ last_connection : str
+ username : str
+ '''
+ self.access = access
+ self.created_by = created_by
+ self.date_created = date_created
+ self.disabled = disabled
+ self.display_name = display_name
+ self.last_connection = last_connection
+ self.username = username
+
+
+class UserInfoRequest(Type):
+ _toSchema = {'entities': 'entities', 'include_disabled': 'include-disabled'}
+ _toPy = {'entities': 'entities', 'include-disabled': 'include_disabled'}
+ def __init__(self, entities=None, include_disabled=None):
+ '''
+ entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ include_disabled : bool
+ '''
+ self.entities = [Entity.from_json(o) for o in entities or []]
+ self.include_disabled = include_disabled
+
+
+class UserInfoResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None):
+ '''
+ error : Error
+ result : UserInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = UserInfo.from_json(result) if result else None
+
+
+class UserInfoResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None):
+ '''
+ results : typing.Sequence<+T_co>[~UserInfoResult]<~UserInfoResult>
+ '''
+ self.results = [UserInfoResult.from_json(o) for o in results or []]
+
+
+class ActionFacade(Type):
+ name = 'Action'
+ version = 2
+ schema = {'definitions': {'Action': {'additionalProperties': False,
+ 'properties': {'name': {'type': 'string'},
+ 'parameters': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'},
+ 'receiver': {'type': 'string'},
+ 'tag': {'type': 'string'}},
+ 'required': ['tag', 'receiver', 'name'],
+ 'type': 'object'},
+ 'ActionResult': {'additionalProperties': False,
+ 'properties': {'action': {'$ref': '#/definitions/Action'},
+ 'completed': {'format': 'date-time',
+ 'type': 'string'},
+ 'enqueued': {'format': 'date-time',
+ 'type': 'string'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'message': {'type': 'string'},
+ 'output': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'},
+ 'started': {'format': 'date-time',
+ 'type': 'string'},
+ 'status': {'type': 'string'}},
+ 'type': 'object'},
+ 'ActionResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/ActionResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ActionSpec': {'additionalProperties': False,
+ 'properties': {'description': {'type': 'string'},
+ 'params': {'patternProperties': {'.*': {'additionalProperties': True,
+ 'type': 'object'}},
+ 'type': 'object'}},
+ 'required': ['description', 'params'],
+ 'type': 'object'},
+ 'Actions': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/Action'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ActionsByName': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionResult'},
+ 'type': 'array'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'name': {'type': 'string'}},
+ 'type': 'object'},
+ 'ActionsByNames': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionsByName'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ActionsByReceiver': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionResult'},
+ 'type': 'array'},
+ 'error': {'$ref': '#/definitions/Error'},
+ 'receiver': {'type': 'string'}},
+ 'type': 'object'},
+ 'ActionsByReceivers': {'additionalProperties': False,
+ 'properties': {'actions': {'items': {'$ref': '#/definitions/ActionsByReceiver'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'ApplicationCharmActionsResult': {'additionalProperties': False,
+ 'properties': {'actions': {'patternProperties': {'.*': {'$ref': '#/definitions/ActionSpec'}},
+ 'type': 'object'},
+ 'application-tag': {'type': 'string'},
+ 'error': {'$ref': '#/definitions/Error'}},
+ 'type': 'object'},
+ 'ApplicationsCharmActionsResults': {'additionalProperties': False,
+ 'properties': {'results': {'items': {'$ref': '#/definitions/ApplicationCharmActionsResult'},
+ 'type': 'array'}},
+ 'type': 'object'},
+ 'Entities': {'additionalProperties': False,
+ 'properties': {'entities': {'items': {'$ref': '#/definitions/Entity'},
+ 'type': 'array'}},
+ 'required': ['entities'],
+ 'type': 'object'},
+ 'Entity': {'additionalProperties': False,
+ 'properties': {'tag': {'type': 'string'}},
+ 'required': ['tag'],