/**
  Juju Firewaller 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 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 BoolResult {
    error?: Error;
    result: boolean;
}
export interface BoolResults {
    results: BoolResult[];
}
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 CloudSpecResults {
    results?: CloudSpecResult[];
}
export interface ControllerAPIInfoResult {
    addresses: string[];
    cacert: string;
    error?: Error;
}
export interface ControllerAPIInfoResults {
    results: ControllerAPIInfoResult[];
}
export interface ControllerConfigResult {
    config: AdditionalProperties;
}
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 FirewallRule {
    "known-service": string;
    "whitelist-cidrs"?: string[];
}
export interface KnownServiceArgs {
    "known-services": string[];
}
export interface LifeResult {
    error?: Error;
    life: string;
}
export interface LifeResults {
    results: LifeResult[];
}
export interface ListFirewallRulesResults {
    Rules: FirewallRule[];
}
export interface Macaroon {
    [key: string]: AdditionalProperties;
}
export interface MacaroonResult {
    error?: Error;
    result?: Macaroon;
}
export interface MacaroonResults {
    results: MacaroonResult[];
}
export interface MachinePortRange {
    "port-range": PortRange;
    "relation-tag": string;
    "unit-tag": string;
}
export interface MachinePorts {
    "machine-tag": string;
    "subnet-tag": string;
}
export interface MachinePortsParams {
    params: MachinePorts[];
}
export interface MachinePortsResult {
    error?: Error;
    ports: MachinePortRange[];
}
export interface MachinePortsResults {
    results: MachinePortsResult[];
}
export interface ModelConfigResult {
    config: AdditionalProperties;
}
export interface ModelTag {
    [key: string]: AdditionalProperties;
}
export interface NotifyWatchResult {
    NotifyWatcherId: string;
    error?: Error;
}
export interface NotifyWatchResults {
    results: NotifyWatchResult[];
}
export interface PortRange {
    "from-port": number;
    protocol: string;
    "to-port": number;
}
export interface SetStatus {
    entities: EntityStatusArgs[];
}
export interface StringResult {
    error?: Error;
    result: string;
}
export interface StringResults {
    results: StringResult[];
}
export interface StringsResult {
    error?: Error;
    result?: string[];
}
export interface StringsResults {
    results: StringsResult[];
}
export interface StringsWatchResult {
    changes?: string[];
    error?: Error;
    "watcher-id": string;
}
export interface StringsWatchResults {
    results: StringsWatchResult[];
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**
  FirewallerAPIV5 provides access to the Firewaller v5 API facade.
*/
declare class FirewallerV5 implements Facade {
    static NAME: string;
    static VERSION: number;
    NAME: string;
    VERSION: number;
    _transport: Transport;
    _info: ConnectionInfo;
    constructor(transport: Transport, info: ConnectionInfo);
    /**
      AreManuallyProvisioned returns whether each given entity is
      manually provisioned or not. Only machine tags are accepted.
    */
    areManuallyProvisioned(params: Entities): Promise<BoolResults>;
    /**
      CloudSpec returns the model's cloud spec.
    */
    cloudSpec(params: Entities): Promise<CloudSpecResults>;
    /**
      ControllerAPIInfoForModels returns the controller api connection details for the specified models.
    */
    controllerAPIInfoForModels(params: Entities): Promise<ControllerAPIInfoResults>;
    /**
      ControllerConfig returns the controller's configuration.
    */
    controllerConfig(params: any): Promise<ControllerConfigResult>;
    /**
      FirewallRules returns the firewall rules for the specified well known service types.
    */
    firewallRules(params: KnownServiceArgs): Promise<ListFirewallRulesResults>;
    /**
      GetAssignedMachine returns the assigned machine tag (if any) for
      each given unit.
    */
    getAssignedMachine(params: Entities): Promise<StringResults>;
    /**
      GetCloudSpec constructs the CloudSpec for a validated and authorized model.
    */
    getCloudSpec(params: ModelTag): Promise<CloudSpecResult>;
    /**
      GetExposed returns the exposed flag value for each given application.
    */
    getExposed(params: Entities): Promise<BoolResults>;
    /**
      GetMachineActiveSubnets returns the tags of the all subnets that each machine
      (in args) has open ports on.
    */
    getMachineActiveSubnets(params: Entities): Promise<StringsResults>;
    /**
      GetMachinePorts returns the port ranges opened on a machine for the specified
      subnet as a map mapping port ranges to the tags of the units that opened
      them.
    */
    getMachinePorts(params: MachinePortsParams): Promise<MachinePortsResults>;
    /**
      InstanceId returns the provider specific instance id for each given
      machine or an CodeNotProvisioned error, if not set.
    */
    instanceId(params: Entities): Promise<StringResults>;
    /**
      Life returns the life status of every supplied entity, where available.
    */
    life(params: Entities): Promise<LifeResults>;
    /**
      MacaroonForRelations returns the macaroon for the specified relations.
    */
    macaroonForRelations(params: Entities): Promise<MacaroonResults>;
    /**
      ModelConfig returns the current model's configuration.
    */
    modelConfig(params: any): Promise<ModelConfigResult>;
    /**
      SetRelationsStatus sets the status for the specified relations.
    */
    setRelationsStatus(params: SetStatus): Promise<ErrorResults>;
    /**
      Watch starts an NotifyWatcher for each given entity.
    */
    watch(params: Entities): Promise<NotifyWatchResults>;
    /**
      WatchCloudSpecsChanges returns a watcher for cloud spec changes.
    */
    watchCloudSpecsChanges(params: Entities): Promise<NotifyWatchResults>;
    /**
      WatchEgressAddressesForRelations creates a watcher that notifies when addresses, from which
      connections will originate for the relation, change.
      Each event contains the entire set of addresses which are required for ingress for the relation.
    */
    watchEgressAddressesForRelations(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>;
    /**
      WatchIngressAddressesForRelations creates a watcher that returns the ingress networks
      that have been recorded against the specified relations.
    */
    watchIngressAddressesForRelations(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchModelMachineStartTimes watches the non-container machines in the model
      for changes to the Life or AgentStartTime fields and reports them as a batch.
    */
    watchModelMachineStartTimes(params: any): Promise<StringsWatchResult>;
    /**
      WatchModelMachines returns a StringsWatcher that notifies of
      changes to the life cycles of the top level machines in the current
      model.
    */
    watchModelMachines(params: any): Promise<StringsWatchResult>;
    /**
      WatchOpenedPorts returns a new StringsWatcher for each given
      model tag.
    */
    watchOpenedPorts(params: Entities): Promise<StringsWatchResults>;
    /**
      WatchUnits starts a StringsWatcher to watch all units belonging to
      to any entity (machine or service) passed in args.
    */
    watchUnits(params: Entities): Promise<StringsWatchResults>;
}
export default FirewallerV5;