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

  NOTE: This file was generated using the Juju schema
  from Juju 3.3 at the git SHA 65fa4c1ee5.
  Do not manually edit this file.
*/
import { ConnectionInfo, Transport } from "../../client.js";
import { Facade } from "../../types.js";
export interface APIHostPortsResult {
    servers: HostPort[][];
}
export interface Address {
    cidr?: string;
    "config-type"?: string;
    "is-secondary"?: boolean;
    scope: string;
    "space-id"?: string;
    "space-name"?: string;
    type: string;
    value: string;
}
export interface Entities {
    entities: Entity[];
}
export interface Entity {
    tag: string;
}
export interface EntityStatusArgs {
    data: AdditionalProperties;
    info: string;
    status: string;
    tag: string;
}
export interface Error {
    code: string;
    info?: AdditionalProperties;
    message: string;
}
export interface ErrorResult {
    error?: Error;
}
export interface ErrorResults {
    results: ErrorResult[];
}
export interface HostPort {
    Address: Address;
    cidr?: string;
    "config-type"?: string;
    "is-secondary"?: boolean;
    port: number;
    scope: string;
    "space-id"?: string;
    "space-name"?: string;
    type: string;
    value: string;
}
export interface JobsResult {
    error?: Error;
    jobs: string[];
}
export interface JobsResults {
    results: JobsResult[];
}
export interface LifeResult {
    error?: Error;
    life: string;
}
export interface LifeResults {
    results: LifeResult[];
}
export interface MachineAddresses {
    addresses: Address[];
    tag: string;
}
export interface NetworkConfig {
    address?: string;
    addresses?: Address[];
    cidr: string;
    "config-type"?: string;
    "device-index": number;
    disabled: boolean;
    "dns-search-domains"?: string[];
    "dns-servers"?: string[];
    "gateway-address"?: string;
    "interface-name": string;
    "interface-type": string;
    "is-default-gateway"?: boolean;
    "mac-address": string;
    mtu: number;
    "no-auto-start"?: boolean;
    origin?: string;
    "parent-interface-name": string;
    "provider-address-id": string;
    "provider-id": string;
    "provider-network-id": string;
    "provider-space-id": string;
    "provider-subnet-id": string;
    "provider-vlan-id": string;
    routes?: NetworkRoute[];
    "shadow-addresses"?: Address[];
    "virtual-port-type"?: string;
    "vlan-tag": number;
}
export interface NetworkRoute {
    "destination-cidr": string;
    "gateway-ip": string;
    metric: number;
}
export interface NotifyWatchResult {
    NotifyWatcherId: string;
    error?: Error;
}
export interface NotifyWatchResults {
    results: NotifyWatchResult[];
}
export interface RecordAgentStartInformationArg {
    hostname?: string;
    tag: string;
}
export interface RecordAgentStartInformationArgs {
    args: RecordAgentStartInformationArg[];
}
export interface SetMachineNetworkConfig {
    config: NetworkConfig[];
    tag: string;
}
export interface SetMachinesAddresses {
    "machine-addresses": MachineAddresses[];
}
export interface SetStatus {
    entities: EntityStatusArgs[];
}
export interface StringsResult {
    error?: Error;
    result?: string[];
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**
  MachinerAPI implements the API used by the machiner worker.
*/
declare class MachinerV5 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>;
    /**
      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>;
    /**
      Jobs returns the jobs assigned to the given entities.
    */
    jobs(params: Entities): Promise<JobsResults>;
    /**
      Life returns the life status of every supplied entity, where available.
    */
    life(params: Entities): Promise<LifeResults>;
    /**
      RecordAgentStartInformation syncs the machine model with information
      reported by a machine agent when it starts.
    */
    recordAgentStartInformation(params: RecordAgentStartInformationArgs): Promise<ErrorResults>;
    /**
      RecordAgentStartTime updates the agent start time field in the machine doc.
    */
    recordAgentStartTime(params: Entities): Promise<ErrorResults>;
    /**
  
    */
    setMachineAddresses(params: SetMachinesAddresses): Promise<ErrorResults>;
    /**
      SetObservedNetworkConfig reads the network config for the machine
      identified by the input args.
      This config is merged with the new network config supplied in the
      same args and updated if it has changed.
    */
    setObservedNetworkConfig(params: SetMachineNetworkConfig): Promise<any>;
    /**
      SetStatus sets the status of each given entity.
    */
    setStatus(params: SetStatus): Promise<ErrorResults>;
    /**
      Watch starts an NotifyWatcher for each given entity.
    */
    watch(params: Entities): Promise<NotifyWatchResults>;
    /**
      WatchAPIHostPorts watches the API server addresses.
    */
    watchAPIHostPorts(params: any): Promise<NotifyWatchResult>;
}
export default MachinerV5;