@canonical/jujulib/dist/api/facades/uniter/UniterV16.d.ts

Juju API client

/**
  Juju Uniter version 16.
  This facade is available on:
    Controller-machine-agent
    Machine-agent
    Unit-agent
    Models

  NOTE: This file was generated using the Juju schema
  from Juju 2.8.2 at the git SHA 516c1904ce.
  Do not manually edit this file.
*/
import { ConnectionInfo, Transport } from "../../client.js";
import { Facade } from "../../types.js";
export interface APIHostPortsResult {
    servers: HostPort[][];
}
export interface Action {
    name: string;
    parameters?: AdditionalProperties;
    receiver: string;
    tag: string;
}
export interface ActionExecutionResult {
    "action-tag": string;
    message?: string;
    results?: AdditionalProperties;
    status: string;
}
export interface ActionExecutionResults {
    results?: ActionExecutionResult[];
}
export interface ActionMessage {
    message: string;
    timestamp: string;
}
export interface ActionMessageParams {
    messages: EntityString[];
}
export interface ActionResult {
    action?: Action;
    completed?: string;
    enqueued?: string;
    error?: Error;
    log?: ActionMessage[];
    message?: string;
    output?: AdditionalProperties;
    started?: string;
    status?: string;
}
export interface ActionResults {
    results?: ActionResult[];
}
export interface Address {
    scope: string;
    "space-id"?: string;
    "space-name"?: string;
    type: string;
    value: string;
}
export interface ApplicationStatusResult {
    application: StatusResult;
    error?: Error;
    units: Record<string, StatusResult>;
}
export interface ApplicationStatusResults {
    results: ApplicationStatusResult[];
}
export interface BoolResult {
    error?: Error;
    result: boolean;
}
export interface BoolResults {
    results: BoolResult[];
}
export interface CharmRelation {
    interface: string;
    limit: number;
    name: string;
    optional: boolean;
    role: string;
    scope: string;
}
export interface CharmURL {
    url: string;
}
export interface CharmURLs {
    urls: CharmURL[];
}
export interface CloudCredential {
    attrs?: Record<string, string>;
    "auth-type": string;
    redacted?: string[];
}
export interface CloudSpec {
    cacertificates?: string[];
    credential?: CloudCredential;
    endpoint?: string;
    "identity-endpoint"?: string;
    name: string;
    region?: string;
    "storage-endpoint"?: string;
    type: string;
}
export interface CloudSpecResult {
    error?: Error;
    result?: CloudSpec;
}
export interface CommitHookChangesArg {
    "add-storage"?: StorageAddParams[];
    "close-ports"?: EntityPortRange[];
    "open-ports"?: EntityPortRange[];
    "pod-spec"?: PodSpec;
    "relation-unit-settings"?: RelationUnitSettings[];
    "set-raw-k8s-spec"?: PodSpec;
    tag: string;
    "unit-state"?: SetUnitStateArg;
    "update-network-info": boolean;
}
export interface CommitHookChangesArgs {
    args: CommitHookChangesArg[];
}
export interface ConfigSettingsResult {
    error?: Error;
    settings: AdditionalProperties;
}
export interface ConfigSettingsResults {
    results: ConfigSettingsResult[];
}
export interface Endpoint {
    "application-name": string;
    relation: CharmRelation;
}
export interface Entities {
    entities: Entity[];
}
export interface EntitiesCharmURL {
    entities: EntityCharmURL[];
}
export interface EntitiesPortRanges {
    entities: EntityPortRange[];
}
export interface Entity {
    tag: string;
}
export interface EntityCharmURL {
    "charm-url": string;
    tag: string;
}
export interface EntityPortRange {
    "from-port": number;
    protocol: string;
    tag: string;
    "to-port": number;
}
export interface EntityStatusArgs {
    data: AdditionalProperties;
    info: string;
    status: string;
    tag: string;
}
export interface EntityString {
    tag: string;
    value: string;
}
export interface EntityWorkloadVersion {
    tag: string;
    "workload-version": string;
}
export interface EntityWorkloadVersions {
    entities: EntityWorkloadVersion[];
}
export interface Error {
    code: string;
    info?: AdditionalProperties;
    message: string;
}
export interface ErrorResult {
    error?: Error;
}
export interface ErrorResults {
    results: ErrorResult[];
}
export interface GetLeadershipSettingsBulkResults {
    results: GetLeadershipSettingsResult[];
}
export interface GetLeadershipSettingsResult {
    error?: Error;
    settings: Record<string, string>;
}
export interface GoalState {
    relations: Record<string, Record<string, GoalStateStatus>>;
    units: Record<string, GoalStateStatus>;
}
export interface GoalStateResult {
    error: Error;
    result: GoalState;
}
export interface GoalStateResults {
    results: GoalStateResult[];
}
export interface GoalStateStatus {
    since: string;
    status: string;
}
export interface HostPort {
    Address: Address;
    port: number;
    scope: string;
    "space-id"?: string;
    "space-name"?: string;
    type: string;
    value: string;
}
export interface IntResult {
    error?: Error;
    result: number;
}
export interface IntResults {
    results: IntResult[];
}
export interface InterfaceAddress {
    cidr: string;
    hostname: string;
    value: string;
}
export interface LifeResult {
    error?: Error;
    life: string;
}
export interface LifeResults {
    results: LifeResult[];
}
export interface MachinePortRange {
    "port-range": PortRange;
    "relation-tag": string;
    "unit-tag": string;
}
export interface MachinePortsResult {
    error?: Error;
    ports: MachinePortRange[];
}
export interface MachinePortsResults {
    results: MachinePortsResult[];
}
export interface MergeLeadershipSettingsBulkParams {
    params: MergeLeadershipSettingsParam[];
}
export interface MergeLeadershipSettingsParam {
    "application-tag"?: string;
    settings: Record<string, string>;
    "unit-tag"?: string;
}
export interface MeterStatusResult {
    code: string;
    error?: Error;
    info: string;
}
export interface MeterStatusResults {
    results: MeterStatusResult[];
}
export interface Metric {
    key: string;
    labels?: Record<string, string>;
    time: string;
    value: string;
}
export interface MetricBatch {
    "charm-url": string;
    created: string;
    metrics: Metric[];
    uuid: string;
}
export interface MetricBatchParam {
    batch: MetricBatch;
    tag: string;
}
export interface MetricBatchParams {
    batches: MetricBatchParam[];
}
export interface ModelConfigResult {
    config: AdditionalProperties;
}
export interface ModelResult {
    error?: Error;
    name: string;
    type: string;
    uuid: string;
}
export interface NetworkInfo {
    addresses: InterfaceAddress[];
    "interface-name": string;
    "mac-address": string;
}
export interface NetworkInfoParams {
    bindings: string[];
    "relation-id"?: number;
    unit: string;
}
export interface NetworkInfoResult {
    "bind-addresses"?: NetworkInfo[];
    "egress-subnets"?: string[];
    error?: Error;
    "ingress-addresses"?: string[];
}
export interface NetworkInfoResults {
    results: Record<string, NetworkInfoResult>;
}
export interface NotifyWatchResult {
    NotifyWatcherId: string;
    error?: Error;
}
export interface NotifyWatchResults {
    results: NotifyWatchResult[];
}
export interface PodSpec {
    spec?: string;
    tag: string;
}
export interface PortRange {
    "from-port": number;
    protocol: string;
    "to-port": number;
}
export interface RelationIds {
    "relation-ids": number[];
}
export interface RelationResult {
    bool?: boolean;
    endpoint: Endpoint;
    error?: Error;
    id: number;
    key: string;
    life: string;
    "other-application"?: string;
}
export interface RelationResults {
    results: RelationResult[];
}
export interface RelationStatusArg {
    message: string;
    "relation-id": number;
    status: string;
    "unit-tag": string;
}
export interface RelationStatusArgs {
    args: RelationStatusArg[];
}
export interface RelationUnit {
    relation: string;
    unit: string;
}
export interface RelationUnitPair {
    "local-unit": string;
    relation: string;
    "remote-unit": string;
}
export interface RelationUnitPairs {
    "relation-unit-pairs": RelationUnitPair[];
}
export interface RelationUnitSettings {
    "application-settings": Record<string, string>;
    relation: string;
    settings: Record<string, string>;
    unit: string;
}
export interface RelationUnitStatus {
    "in-scope": boolean;
    "relation-tag": string;
    suspended: boolean;
}
export interface RelationUnitStatusResult {
    error?: Error;
    results: RelationUnitStatus[];
}
export interface RelationUnitStatusResults {
    results: RelationUnitStatusResult[];
}
export interface RelationUnits {
    "relation-units": RelationUnit[];
}
export interface RelationUnitsChange {
    "app-changed"?: Record<string, number>;
    changed: Record<string, UnitSettings>;
    departed?: string[];
}
export interface RelationUnitsSettings {
    "relation-units": RelationUnitSettings[];
}
export interface RelationUnitsWatchResult {
    changes: RelationUnitsChange;
    error?: Error;
    "watcher-id": string;
}
export interface RelationUnitsWatchResults {
    results: RelationUnitsWatchResult[];
}
export interface ResolvedModeResult {
    error?: Error;
    mode: string;
}
export interface ResolvedModeResults {
    results: ResolvedModeResult[];
}
export interface SetStatus {
    entities: EntityStatusArgs[];
}
export interface SetUnitStateArg {
    "charm-state"?: Record<string, string>;
    "meter-status-state"?: string;
    "relation-state"?: Record<string, string>;
    "storage-state"?: string;
    tag: string;
    "uniter-state"?: string;
}
export interface SetUnitStateArgs {
    args: SetUnitStateArg[];
}
export interface SettingsResult {
    error?: Error;
    settings: Record<string, string>;
}
export interface SettingsResults {
    results: SettingsResult[];
}
export interface StatusResult {
    data: AdditionalProperties;
    error?: Error;
    id: string;
    info: string;
    life: string;
    since: string;
    status: string;
}
export interface StatusResults {
    results: StatusResult[];
}
export interface StorageAddParams {
    name: string;
    storage: StorageConstraints;
    unit: string;
}
export interface StorageAttachment {
    kind: number;
    life: string;
    location: string;
    "owner-tag": string;
    "storage-tag": string;
    "unit-tag": string;
}
export interface StorageAttachmentId {
    "storage-tag": string;
    "unit-tag": string;
}
export interface StorageAttachmentIds {
    ids: StorageAttachmentId[];
}
export interface StorageAttachmentIdsResult {
    error?: Error;
    result: StorageAttachmentIds;
}
export interface StorageAttachmentIdsResults {
    results?: StorageAttachmentIdsResult[];
}
export interface StorageAttachmentResult {
    error?: Error;
    result: StorageAttachment;
}
export interface StorageAttachmentResults {
    results?: StorageAttachmentResult[];
}
export interface StorageConstraints {
    count?: number;
    pool?: string;
    size?: number;
}
export interface StoragesAddParams {
    storages: StorageAddParams[];
}
export interface StringBoolResult {
    error?: Error;
    ok: boolean;
    result: string;
}
export interface StringBoolResults {
    results: StringBoolResult[];
}
export interface StringResult {
    error?: Error;
    result: string;
}
export interface StringResults {
    results: StringResult[];
}
export interface StringsResult {
    error?: Error;
    result?: string[];
}
export interface StringsWatchResult {
    changes?: string[];
    error?: Error;
    "watcher-id": string;
}
export interface StringsWatchResults {
    results: StringsWatchResult[];
}
export interface UnitRefreshResult {
    Error: Error;
    Life: string;
    Resolved: string;
    "provider-id"?: string;
}
export interface UnitRefreshResults {
    Results: UnitRefreshResult[];
}
export interface UnitSettings {
    version: number;
}
export interface UnitStateResult {
    "charm-state"?: Record<string, string>;
    error?: Error;
    "meter-status-state"?: string;
    "relation-state"?: Record<string, string>;
    "storage-state"?: string;
    "uniter-state"?: string;
}
export interface UnitStateResults {
    results: UnitStateResult[];
}
export interface UpgradeSeriesStatusParam {
    entity: Entity;
    message: string;
    status: string;
}
export interface UpgradeSeriesStatusParams {
    params: UpgradeSeriesStatusParam[];
}
export interface UpgradeSeriesStatusResult {
    error?: Error;
    status?: string;
}
export interface UpgradeSeriesStatusResults {
    results?: UpgradeSeriesStatusResult[];
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**
  UniterAPI implements the latest version (v16) of the Uniter API, which adds
  LXDProfileAPIv2.
*/
declare class UniterV16 implements Facade {
    static NAME: string;
    static VERSION: number;
    NAME: string;
    VERSION: number;
    _transport: Transport;
    _info: ConnectionInfo;
    constructor(transport: Transport, info: ConnectionInfo);
    /**
      APIAddresses returns the list of addresses used to connect to the API.
    */
    aPIAddresses(params: any): Promise<StringsResult>;
    /**
      APIHostPorts returns the API server addresses.
    */
    aPIHostPorts(params: any): Promise<APIHostPortsResult>;
    /**
      ActionStatus returns the status of Actions by Tags passed in.
    */
    actionStatus(params: Entities): Promise<StringResults>;
    /**
      Actions returns the Actions by Tags passed and ensures that the Unit asking
      for them is the same Unit that has the Actions.
    */
    actions(params: Entities): Promise<ActionResults>;
    /**
      AddMetricBatches adds the metrics for the specified unit.
    */
    addMetricBatches(params: MetricBatchParams): Promise<ErrorResults>;
    /**
      AddUnitStorage validates and creates additional storage instances for units.
      Failures on an individual storage instance do not block remaining
      instances from being processed.
    */
    addUnitStorage(params: StoragesAddParams): Promise<ErrorResults>;
    /**
      AllMachinePorts returns all opened port ranges for each given
      machine (on all networks).
    */
    allMachinePorts(params: Entities): Promise<MachinePortsResults>;
    /**
      ApplicationStatus returns the status of the Applications and its workloads
      if the given unit is the leader.
    */
    applicationStatus(params: Entities): Promise<ApplicationStatusResults>;
    /**
      AssignedMachine returns the machine tag for each given unit tag, or
      an error satisfying params.IsCodeNotAssigned when a unit has no
      assigned machine.
    */
    assignedMachine(params: Entities): Promise<StringResults>;
    /**
      AvailabilityZone returns the availability zone for each given unit, if applicable.
    */
    availabilityZone(params: Entities): Promise<StringResults>;
    /**
      BeginActions marks the actions represented by the passed in Tags as running.
    */
    beginActions(params: Entities): Promise<ErrorResults>;
    /**
      CanApplyLXDProfile is a shim to call the LXDProfileAPIv2 version of this method.
    */
    canApplyLXDProfile(params: Entities): Promise<BoolResults>;
    /**
      CharmArchiveSha256 returns the SHA256 digest of the charm archive
      (bundle) data for each charm url in the given parameters.
    */
    charmArchiveSha256(params: CharmURLs): Promise<StringResults>;
    /**
      CharmModifiedVersion returns the most CharmModifiedVersion for all given
      units or applications.
    */
    charmModifiedVersion(params: Entities): Promise<IntResults>;
    /**
      CharmURL returns the charm URL for all given units or applications.
    */
    charmURL(params: Entities): Promise<StringBoolResults>;
    /**
      ClearResolved removes any resolved setting from each given unit.
    */
    clearResolved(params: Entities): Promise<ErrorResults>;
    /**
      ClosePorts sets the policy of the port range with protocol to be
      closed, for all given units.
    */
    closePorts(params: EntitiesPortRanges): Promise<ErrorResults>;
    /**
      CloudAPIVersion returns the cloud API version, if available.
    */
    cloudAPIVersion(params: any): Promise<StringResult>;
    /**
      CloudSpec returns the cloud spec used by the model in which the
      authenticated unit or application resides.
      A check is made beforehand to ensure that the request is made by an entity
      that has been granted the appropriate trust.
    */
    cloudSpec(params: any): Promise<CloudSpecResult>;
    /**
      CommitHookChanges batches together all required API calls for applying
      a set of changes after a hook successfully completes and executes them in a
      single transaction.
    */
    commitHookChanges(params: CommitHookChangesArgs): Promise<ErrorResults>;
    /**
      ConfigSettings returns the complete set of application charm config
      settings available to each given unit.
    */
    configSettings(params: Entities): Promise<ConfigSettingsResults>;
    /**
      CurrentModel returns the name and UUID for the current juju model.
    */
    currentModel(params: any): Promise<ModelResult>;
    /**
      Destroy advances all given Alive units' lifecycles as far as
      possible. See state/Unit.Destroy().
    */
    destroy(params: Entities): Promise<ErrorResults>;
    /**
      DestroyAllSubordinates destroys all subordinates of each given unit.
    */
    destroyAllSubordinates(params: Entities): Promise<ErrorResults>;
    /**
      DestroyUnitStorageAttachments marks each storage attachment of the
      specified units as Dying.
    */
    destroyUnitStorageAttachments(params: Entities): Promise<ErrorResults>;
    /**
      EnsureDead calls EnsureDead on each given entity from state. It
      will fail if the entity is not present. If it's Alive, nothing will
      happen (see state/EnsureDead() for units or machines).
    */
    ensureDead(params: Entities): Promise<ErrorResults>;
    /**
      EnterScope ensures each unit has entered its scope in the relation,
      for all of the given relation/unit pairs. See also
      state.RelationUnit.EnterScope().
    */
    enterScope(params: RelationUnits): Promise<ErrorResults>;
    /**
      FinishActions saves the result of a completed Action
    */
    finishActions(params: ActionExecutionResults): Promise<ErrorResults>;
    /**
  
    */
    getMeterStatus(params: Entities): Promise<MeterStatusResults>;
    /**
      GetPodSpec gets the pod specs for a set of applications.
    */
    getPodSpec(params: Entities): Promise<StringResults>;
    /**
      GetPrincipal returns the result of calling PrincipalName() and
      converting it to a tag, on each given unit.
    */
    getPrincipal(params: Entities): Promise<StringBoolResults>;
    /**
      GetRawK8sSpec gets the raw k8s specs for a set of applications.
    */
    getRawK8sSpec(params: Entities): Promise<StringResults>;
    /**
      GoalStates returns information of charm units and relations.
    */
    goalStates(params: Entities): Promise<GoalStateResults>;
    /**
      HasSubordinates returns the whether each given unit has any subordinates.
    */
    hasSubordinates(params: Entities): Promise<BoolResults>;
    /**
      LXDProfileName is a shim to call the LXDProfileAPIv2 version of this method.
    */
    lXDProfileName(params: Entities): Promise<StringResults>;
    /**
      LXDProfileRequired is a shim to call the LXDProfileAPIv2 version of this method.
    */
    lXDProfileRequired(params: CharmURLs): Promise<BoolResults>;
    /**
      LeaveScope signals each unit has left its scope in the relation,
      for all of the given relation/unit pairs. See also
      state.RelationUnit.LeaveScope().
    */
    leaveScope(params: RelationUnits): Promise<ErrorResults>;
    /**
      Life returns the life status of every supplied entity, where available.
    */
    life(params: Entities): Promise<LifeResults>;
    /**
      LogActionsMessages records the log messages against the specified actions.
    */
    logActionsMessages(params: ActionMessageParams): Promise<ErrorResults>;
    /**
      Merge merges in the provided leadership settings. Only leaders for
      the given service may perform this operation.
    */
    merge(params: MergeLeadershipSettingsBulkParams): Promise<ErrorResults>;
    /**
      ModelConfig returns the current model's configuration.
    */
    modelConfig(params: any): Promise<ModelConfigResult>;
    /**
      ModelUUID returns the model UUID to connect to the model
      that the current connection is for.
    */
    modelUUID(params: any): Promise<StringResult>;
    /**
      NetworkInfo returns network interfaces/addresses for specified bindings.
    */
    networkInfo(params: NetworkInfoParams): Promise<NetworkInfoResults>;
    /**
      OpenPorts sets the policy of the port range with protocol to be
      opened, for all given units.
    */
    openPorts(params: EntitiesPortRanges): Promise<ErrorResults>;
    /**
      PrivateAddress returns the private address for each given unit, if set.
    */
    privateAddress(params: Entities): Promise<StringResults>;
    /**
      ProviderType returns the provider type used by the current juju
      model.
  
      TODO(dimitern): Refactor the uniter to call this instead of calling
      ModelConfig() just to get the provider type. Once we have machine
      addresses, this might be completely unnecessary though.
    */
    providerType(params: any): Promise<StringResult>;
    /**
      PublicAddress returns the public address for each given unit, if set.
    */
    publicAddress(params: Entities): Promise<StringResults>;
    /**
      Read reads leadership settings for the provided service ID. Any
      unit of the service may perform this operation.
    */
    read(params: Entities): Promise<GetLeadershipSettingsBulkResults>;
    /**
      ReadLocalApplicationSettings returns the local application settings for a
      particular relation when invoked by the leader unit.
    */
    readLocalApplicationSettings(params: RelationUnit): Promise<SettingsResult>;
    /**
      ReadRemoteSettings returns the remote settings of each given set of
      relation/local unit/remote unit.
    */
    readRemoteSettings(params: RelationUnitPairs): Promise<SettingsResults>;
    /**
      ReadSettings returns the local settings of each given set of
      relation/unit.
  
      NOTE(achilleasa): Using this call to read application data is deprecated
      and will not work for k8s charms (see LP1876097). Instead, clients should
      use ReadLocalApplicationSettings.
    */
    readSettings(params: RelationUnits): Promise<SettingsResults>;
    /**
      Refresh retrieves the latest values for attributes on this unit.
    */
    refresh(params: Entities): Promise<UnitRefreshResults>;
    /**
      Relation returns information about all given relation/unit pairs,
      including their id, key and the local endpoint.
    */
    relation(params: RelationUnits): Promise<RelationResults>;
    /**
      RelationById returns information about all given relations,
      specified by their ids, including their key and the local
      endpoint.
    */
    relationById(params: RelationIds): Promise<RelationResults>;
    /**
      RelationsStatus returns for each unit the corresponding relation and status information.
    */
    relationsStatus(params: Entities): Promise<RelationUnitStatusResults>;
    /**
      RemoveStorageAttachments removes the specified storage
      attachments from state.
    */
    removeStorageAttachments(params: StorageAttachmentIds): Promise<ErrorResults>;
    /**
      RequestReboot sets the reboot flag on the provided machines
    */
    requestReboot(params: Entities): Promise<ErrorResults>;
    /**
      Resolved returns the current resolved setting for each given unit.
    */
    resolved(params: Entities): Promise<ResolvedModeResults>;
    /**
      SLALevel returns the model's SLA level.
    */
    sLALevel(params: any): Promise<StringResult>;
    /**
      SetAgentStatus will set status for agents of Units passed in args, if one
      of the args is not an Unit it will fail.
    */
    setAgentStatus(params: SetStatus): Promise<ErrorResults>;
    /**
      SetApplicationStatus sets the status for all the Applications in args if the given Unit is
      the leader.
    */
    setApplicationStatus(params: SetStatus): Promise<ErrorResults>;
    /**
      SetCharmURL sets the charm URL for each given unit. An error will
      be returned if a unit is dead, or the charm URL is not known.
    */
    setCharmURL(params: EntitiesCharmURL): Promise<ErrorResults>;
    /**
      SetRelationStatus updates the status of the specified relations.
    */
    setRelationStatus(params: RelationStatusArgs): Promise<ErrorResults>;
    /**
      SetState sets the state persisted by the charm running in this unit
      and the state internal to the uniter for this unit.
    */
    setState(params: SetUnitStateArgs): Promise<ErrorResults>;
    /**
      SetStatus will set status for a entities passed in args. If the entity is
      a Unit it will instead set status to its agent, to emulate backwards
      compatibility.
    */
    setStatus(params: SetStatus): Promise<ErrorResults>;
    /**
      SetUnitStatus sets status for all elements passed in args, the difference
      with SetStatus is that if an entity is a Unit it will set its status instead
      of its agent.
    */
    setUnitStatus(params: SetStatus): Promise<ErrorResults>;
    /**
      SetUpgradeSeriesUnitStatus sets the upgrade series status of the unit.
      If no upgrade is in progress an error is returned instead.
    */
    setUpgradeSeriesUnitStatus(params: UpgradeSeriesStatusParams): Promise<ErrorResults>;
    /**
      SetWorkloadVersion sets the workload version for each given unit. An error will
      be returned if a unit is dead.
    */
    setWorkloadVersion(params: EntityWorkloadVersions): Promise<ErrorResults>;
    /**
      State returns the state persisted by the charm running in this unit
      and the state internal to the uniter for this unit.
    */
    state(params: Entities): Promise<UnitStateResults>;
    /**
      StorageAttachmentLife returns the lifecycle state of the storage attachments
      with the specified tags.
    */
    storageAttachmentLife(params: StorageAttachmentIds): Promise<LifeResults>;
    /**
      StorageAttachments returns the storage attachments with the specified tags.
    */
    storageAttachments(params: StorageAttachmentIds): Promise<StorageAttachmentResults>;
    /**
      UnitStatus returns the workload status information for the unit.
    */
    unitStatus(params: Entities): Promise<StatusResults>;
    /**
      UnitStorageAttachments returns the IDs of storage attachments for a collection of units.
    */
    unitStorageAttachments(params: Entities): Promise<StorageAttachmentIdsResults>;
    /**
      UpdateNetworkInfo refreshes the network settings for a unit's bound
      endpoints.
    */
    updateNetworkInfo(params: Entities): Promise<ErrorResults>;
    /**
      UpdateSettings persists all changes made to the local settings of
      all given pairs of relation and unit. Keys with empty values are
      considered a signal to delete these values.
    */
    updateSettings(params: RelationUnitsSettings): Promise<ErrorResults>;
    /**
      UpgradeSeriesUnitStatus returns the current preparation status of an
      upgrading unit.
      If no series upgrade is in progress an error is returned instead.
    */
    upgradeSeriesUnitStatus(params: Entities): Promise<UpgradeSeriesStatusResults>;
    /**
      Watch starts an NotifyWatcher for each given entity.
    */
    watch(params: Entities): Promise<NotifyWatchResults>;
    /**
      WatchAPIHostPorts watches the API server addresses.
    */
    watchAPIHostPorts(params: any): Promise<NotifyWatchResult>;
    /**
      WatchActionNotifications returns a StringsWatcher for observing
      incoming action calls to a unit. See also state/watcher.go
      Unit.WatchActionNotifications(). This method is called from
      api/uniter/uniter.go WatchActionNotifications().
    */
    watchActionNotifications(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchConfigSettingsHash returns a StringsWatcher that yields a hash
      of the config values every time the config changes. The uniter can
      save this hash and use it to decide whether the config-changed hook
      needs to be run (or whether this was just an agent restart with no
      substantive config change).
    */
    watchConfigSettingsHash(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchForModelConfigChanges returns a NotifyWatcher that observes
      changes to the model configuration.
      Note that although the NotifyWatchResult contains an Error field,
      it's not used because we are only returning a single watcher,
      so we use the regular error return.
    */
    watchForModelConfigChanges(params: any): Promise<NotifyWatchResult>;
    /**
      WatchInstanceData is a shim to call the LXDProfileAPIv2 version of this method.
    */
    watchInstanceData(params: Entities): Promise<NotifyWatchResults>;
    /**
      WatchLeadershipSettings will block the caller until leadership settings
      for the given service ID change.
    */
    watchLeadershipSettings(params: Entities): Promise<NotifyWatchResults>;
    /**
  
    */
    watchMeterStatus(params: Entities): Promise<NotifyWatchResults>;
    /**
      WatchRelationUnits returns a RelationUnitsWatcher for observing
      changes to every unit in the supplied relation that is visible to
      the supplied unit. See also state/watcher.go:RelationUnit.Watch().
    */
    watchRelationUnits(params: RelationUnits): Promise<RelationUnitsWatchResults>;
    /**
      WatchStorageAttachments creates watchers for a collection of storage
      attachments, each of which can be used to watch changes to storage
      attachment info.
    */
    watchStorageAttachments(params: StorageAttachmentIds): Promise<NotifyWatchResults>;
    /**
      WatchTrustConfigSettingsHash returns a StringsWatcher that yields a
      hash of the application config values whenever they change. The
      uniter can use the hash to determine whether the actual values have
      changed since it last saw the config.
    */
    watchTrustConfigSettingsHash(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchUnitAddressesHash returns a StringsWatcher that yields the
      hashes of the addresses for the unit whenever the addresses
      change. The uniter can use the hash to determine whether the actual
      address values have changed since it last saw the config.
    */
    watchUnitAddressesHash(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchUnitRelations returns a StringsWatcher, for each given
      unit, that notifies of changes to the lifecycles of relations
      relevant to that unit. For principal units, this will be all of the
      relations for the application. For subordinate units, only
      relations with the principal unit's application will be monitored.
    */
    watchUnitRelations(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchUnitStorageAttachments creates watchers for a collection of units,
      each of which can be used to watch for lifecycle changes to the corresponding
      unit's storage attachments.
    */
    watchUnitStorageAttachments(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchUpgradeSeriesNotifications returns a NotifyWatcher for observing changes to upgrade series locks.
    */
    watchUpgradeSeriesNotifications(params: Entities): Promise<NotifyWatchResults>;
    /**
      WorkloadVersion returns the workload version for all given units or applications.
    */
    workloadVersion(params: Entities): Promise<StringResults>;
}
export default UniterV16;