@canonical/jujulib/dist/api/facades/firewaller/FirewallerV7.d.ts

Juju API client

/**
  Juju Firewaller version 7.
  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 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;
    "is-controller-cloud"?: boolean;
    name: string;
    region?: string;
    "skip-tls-verify"?: boolean;
    "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 ExposeInfoResult {
    error?: Error;
    exposed?: boolean;
    "exposed-endpoints"?: Record<string, ExposedEndpoint>;
}
export interface ExposeInfoResults {
    results: ExposeInfoResult[];
}
export interface ExposedEndpoint {
    "expose-to-cidrs"?: string[];
    "expose-to-spaces"?: string[];
}
export interface FanConfigEntry {
    overlay: string;
    underlay: string;
}
export interface IngressRule {
    "port-range": PortRange;
    "source-cidrs": string[];
}
export interface IngressRulesResult {
    error?: Error;
    rules: IngressRule[];
}
export interface LifeResult {
    error?: Error;
    life: string;
}
export interface LifeResults {
    results: LifeResult[];
}
export interface Macaroon {
    [key: string]: AdditionalProperties;
}
export interface MacaroonResult {
    error?: Error;
    result?: Macaroon;
}
export interface MacaroonResults {
    results: MacaroonResult[];
}
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 OpenMachinePortRangesResult {
    error?: Error;
    "unit-port-ranges": Record<string, OpenUnitPortRanges[]>;
}
export interface OpenMachinePortRangesResults {
    results: OpenMachinePortRangesResult[];
}
export interface OpenUnitPortRanges {
    endpoint: string;
    "port-ranges": PortRange[];
    "subnet-cidrs": string[];
}
export interface PortRange {
    "from-port": number;
    protocol: string;
    "to-port": number;
}
export interface SetStatus {
    entities: EntityStatusArgs[];
}
export interface SpaceInfo {
    id: string;
    name: string;
    "provider-id"?: string;
    subnets?: SubnetV3[];
}
export interface SpaceInfos {
    "space-infos"?: SpaceInfo[];
}
export interface SpaceInfosParams {
    "space-ids"?: string[];
}
export interface StringResult {
    error?: Error;
    result: string;
}
export interface StringResults {
    results: StringResult[];
}
export interface StringsWatchResult {
    changes?: string[];
    error?: Error;
    "watcher-id": string;
}
export interface StringsWatchResults {
    results: StringsWatchResult[];
}
export interface Subnet {
    cidr: string;
    life: string;
    "provider-id"?: string;
    "provider-network-id"?: string;
    "provider-space-id"?: string;
    "space-tag": string;
    status?: string;
    "vlan-tag": number;
    zones: string[];
}
export interface SubnetV2 {
    Subnet: Subnet;
    cidr: string;
    id?: string;
    life: string;
    "provider-id"?: string;
    "provider-network-id"?: string;
    "provider-space-id"?: string;
    "space-tag": string;
    status?: string;
    "vlan-tag": number;
    zones: string[];
}
export interface SubnetV3 {
    Subnet: Subnet;
    SubnetV2: SubnetV2;
    cidr: string;
    "fan-info"?: FanConfigEntry;
    id?: string;
    "is-public"?: boolean;
    life: string;
    "provider-id"?: string;
    "provider-network-id"?: string;
    "provider-space-id"?: string;
    "space-id": string;
    "space-tag": string;
    status?: string;
    "vlan-tag": number;
    zones: string[];
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**
  FirewallerAPI provides access to the Firewaller API facade.
*/
declare class FirewallerV7 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>;
    /**
      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>;
    /**
      GetExposeInfo returns the expose flag and per-endpoint expose settings
      for the specified applications.
    */
    getExposeInfo(params: Entities): Promise<ExposeInfoResults>;
    /**
      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>;
    /**
      ModelFirewallRules returns the firewall rules that this model is
      configured to open
    */
    modelFirewallRules(params: any): Promise<IngressRulesResult>;
    /**
      OpenedMachinePortRanges returns a list of the opened port ranges for the
      specified machines where each result is broken down by unit. The list of
      opened ports for each unit is further grouped by endpoint name and includes
      the subnet CIDRs that belong to the space that each endpoint is bound to.
    */
    openedMachinePortRanges(params: Entities): Promise<OpenMachinePortRangesResults>;
    /**
      SetRelationsStatus sets the status for the specified relations.
    */
    setRelationsStatus(params: SetStatus): Promise<ErrorResults>;
    /**
      SpaceInfos returns a comprehensive representation of either all spaces or
      a filtered subset of the known spaces and their associated subnet details.
    */
    spaceInfos(params: SpaceInfosParams): Promise<SpaceInfos>;
    /**
      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>;
    /**
      WatchModelFirewallRules returns a NotifyWatcher that notifies of
      potential changes to a model's configured firewall rules
    */
    watchModelFirewallRules(params: any): Promise<NotifyWatchResult>;
    /**
      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>;
    /**
      WatchSubnets returns a new StringsWatcher that watches the specified
      subnet tags or all tags if no entities are specified.
    */
    watchSubnets(params: Entities): Promise<StringsWatchResult>;
    /**
      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 FirewallerV7;