@canonical/jujulib/dist/api/facades/client/ClientV2.d.ts

Juju API client

/**
  Juju Client version 2.
  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.9-rc3 at the git SHA cb361902f8.
  Do not manually edit this file.
*/
import { ConnectionInfo, Transport } from "../../client.js";
import { Facade } from "../../types.js";
export interface APIHostPortsResult {
    servers: HostPort[][];
}
export interface AddCharm {
    channel: string;
    force: boolean;
    url: string;
}
export interface AddCharmWithAuthorization {
    channel: string;
    force: boolean;
    macaroon: Macaroon;
    url: string;
}
export interface AddMachineParams {
    addresses: Address[];
    constraints: Value;
    "container-type": string;
    disks?: Constraints[];
    "hardware-characteristics": HardwareCharacteristics;
    "instance-id": string;
    jobs: string[];
    nonce: string;
    "parent-id": string;
    placement?: Placement;
    series: string;
}
export interface AddMachines {
    params: AddMachineParams[];
}
export interface AddMachinesResult {
    error?: Error;
    machine: string;
}
export interface AddMachinesResults {
    machines: AddMachinesResult[];
}
export interface Address {
    scope: string;
    "space-id"?: string;
    "space-name"?: string;
    type: string;
    value: string;
}
export interface AgentVersionResult {
    version: Number;
}
export interface AllWatcherId {
    "watcher-id": string;
}
export interface ApplicationOfferStatus {
    "active-connected-count": number;
    "application-name": string;
    charm: string;
    endpoints: Record<string, RemoteEndpoint>;
    err?: Error;
    "offer-name": string;
    "total-connected-count": number;
}
export interface ApplicationStatus {
    "can-upgrade-to": string;
    charm: string;
    "charm-profile": string;
    "charm-version": string;
    "endpoint-bindings": Record<string, string>;
    err?: Error;
    exposed: boolean;
    "exposed-endpoints"?: Record<string, ExposedEndpoint>;
    int?: number;
    life: string;
    "meter-statuses": Record<string, MeterStatus>;
    "provider-id"?: string;
    "public-address": string;
    relations: Record<string, string[]>;
    series: string;
    status: DetailedStatus;
    "subordinate-to": string[];
    units: Record<string, UnitStatus>;
    "workload-version": string;
}
export interface Binary {
    Arch: string;
    Build: number;
    Major: number;
    Minor: number;
    Number: Number;
    Patch: number;
    Series: string;
    Tag: string;
}
export interface BranchStatus {
    "assigned-units": Record<string, string[]>;
    created: number;
    "created-by": string;
}
export interface BundleChange {
    args: object[];
    id: string;
    method: string;
    requires: string[];
}
export interface BundleChangesParams {
    bundleURL: string;
    yaml: string;
}
export interface BundleChangesResults {
    changes?: BundleChange[];
    errors?: string[];
}
export interface BytesResult {
    result: number[];
}
export interface ConfigValue {
    source: string;
    value: AdditionalProperties;
}
export interface Constraints {
    Count: number;
    Pool: string;
    Size: number;
}
export interface DestroyMachines {
    force: boolean;
    "machine-names": string[];
}
export interface DetailedStatus {
    data: AdditionalProperties;
    err?: Error;
    info: string;
    kind: string;
    life: string;
    since: string;
    status: string;
    version: string;
}
export interface EndpointStatus {
    application: string;
    name: string;
    role: string;
    subordinate: boolean;
}
export interface Entities {
    entities: Entity[];
}
export interface Entity {
    tag: string;
}
export interface EntityStatus {
    data?: AdditionalProperties;
    info: string;
    since: string;
    status: string;
}
export interface Error {
    code: string;
    info?: AdditionalProperties;
    message: string;
}
export interface ErrorResult {
    error?: Error;
}
export interface ErrorResults {
    results: ErrorResult[];
}
export interface ExposedEndpoint {
    "expose-to-cidrs"?: string[];
    "expose-to-spaces"?: string[];
}
export interface FindToolsParams {
    agentstream: string;
    arch: string;
    major: number;
    minor: number;
    number: Number;
    series: string;
}
export interface FindToolsResult {
    error?: Error;
    list: Tools[];
}
export interface FullStatus {
    applications: Record<string, ApplicationStatus>;
    branches: Record<string, BranchStatus>;
    "controller-timestamp": string;
    machines: Record<string, MachineStatus>;
    model: ModelStatusInfo;
    offers: Record<string, ApplicationOfferStatus>;
    relations: RelationStatus[];
    "remote-applications": Record<string, RemoteApplicationStatus>;
}
export interface GetConstraintsResults {
    constraints: Value;
}
export interface HardwareCharacteristics {
    arch?: string;
    "availability-zone"?: string;
    "cpu-cores"?: number;
    "cpu-power"?: number;
    mem?: number;
    "root-disk"?: number;
    "root-disk-source"?: string;
    tags?: string[];
}
export interface History {
    error?: Error;
    statuses: DetailedStatus[];
}
export interface HostPort {
    Address: Address;
    port: number;
    scope: string;
    "space-id"?: string;
    "space-name"?: string;
    type: string;
    value: string;
}
export interface LXDProfile {
    config: Record<string, string>;
    description: string;
    devices: Record<string, Record<string, string>>;
}
export interface Macaroon {
    [key: string]: AdditionalProperties;
}
export interface MachineHardware {
    arch?: string;
    "availability-zone"?: string;
    cores?: number;
    "cpu-power"?: number;
    mem?: number;
    "root-disk"?: number;
    tags?: string[];
}
export interface MachineStatus {
    "agent-status": DetailedStatus;
    constraints: string;
    containers: Record<string, MachineStatus>;
    "display-name": string;
    "dns-name": string;
    hardware: string;
    "has-vote": boolean;
    id: string;
    "instance-id": string;
    "instance-status": DetailedStatus;
    "ip-addresses"?: string[];
    jobs: string[];
    "lxd-profiles"?: Record<string, LXDProfile>;
    "modification-status": DetailedStatus;
    "network-interfaces"?: Record<string, NetworkInterface>;
    "primary-controller-machine"?: boolean;
    series: string;
    "wants-vote": boolean;
}
export interface MeterStatus {
    color: string;
    message: string;
}
export interface ModelConfigResults {
    config: Record<string, ConfigValue>;
}
export interface ModelInfo {
    "agent-version": string;
    "cloud-credential-tag"?: string;
    "cloud-credential-validity"?: boolean;
    "cloud-region"?: string;
    "cloud-tag": string;
    "controller-uuid": string;
    "default-series"?: string;
    "is-controller": boolean;
    life: string;
    machines: ModelMachineInfo[];
    migration?: ModelMigrationStatus;
    name: string;
    "owner-tag": string;
    "provider-type"?: string;
    sla: ModelSLAInfo;
    status?: EntityStatus;
    type: string;
    users: ModelUserInfo[];
    uuid: string;
}
export interface ModelMachineInfo {
    "display-name"?: string;
    "ha-primary"?: boolean;
    hardware?: MachineHardware;
    "has-vote"?: boolean;
    id: string;
    "instance-id"?: string;
    message?: string;
    status?: string;
    "wants-vote"?: boolean;
}
export interface ModelMigrationStatus {
    end?: string;
    start: string;
    status: string;
}
export interface ModelSLA {
    ModelSLAInfo: ModelSLAInfo;
    creds: number[];
    level: string;
    owner: string;
}
export interface ModelSLAInfo {
    level: string;
    owner: string;
}
export interface ModelSet {
    config: AdditionalProperties;
}
export interface ModelStatusInfo {
    "available-version": string;
    "cloud-tag": string;
    "meter-status": MeterStatus;
    "model-status": DetailedStatus;
    name: string;
    region?: string;
    sla: string;
    type: string;
    version: string;
}
export interface ModelUnset {
    keys: string[];
}
export interface ModelUserInfo {
    access: string;
    "display-name": string;
    "last-connection": string;
    user: string;
}
export interface ModelUserInfoResult {
    error?: Error;
    result?: ModelUserInfo;
}
export interface ModelUserInfoResults {
    results: ModelUserInfoResult[];
}
export interface NetworkInterface {
    "dns-nameservers"?: string[];
    gateway?: string;
    "ip-addresses": string[];
    "is-up": boolean;
    "mac-address": string;
    space?: string;
}
export interface Number {
    Build: number;
    Major: number;
    Minor: number;
    Patch: number;
    Tag: string;
}
export interface Placement {
    directive: string;
    scope: string;
}
export interface PrivateAddress {
    target: string;
}
export interface PrivateAddressResults {
    "private-address": string;
}
export interface ProvisioningScriptParams {
    "data-dir": string;
    "disable-package-commands": boolean;
    "machine-id": string;
    nonce: string;
}
export interface ProvisioningScriptResult {
    script: string;
}
export interface PublicAddress {
    target: string;
}
export interface PublicAddressResults {
    "public-address": string;
}
export interface RelationStatus {
    endpoints: EndpointStatus[];
    id: number;
    interface: string;
    key: string;
    scope: string;
    status: DetailedStatus;
}
export interface RemoteApplicationStatus {
    endpoints: RemoteEndpoint[];
    err?: Error;
    life: string;
    "offer-name": string;
    "offer-url": string;
    relations: Record<string, string[]>;
    status: DetailedStatus;
}
export interface RemoteEndpoint {
    interface: string;
    limit: number;
    name: string;
    role: string;
}
export interface ResolveCharmResult {
    error?: string;
    url?: string;
}
export interface ResolveCharmResults {
    urls: ResolveCharmResult[];
}
export interface ResolveCharms {
    references: string[];
}
export interface Resolved {
    retry: boolean;
    "unit-name": string;
}
export interface SetConstraints {
    application: string;
    constraints: Value;
}
export interface SetModelAgentVersion {
    force?: boolean;
    version: Number;
}
export interface StatusHistoryFilter {
    date: string;
    delta: number;
    exclude: string[];
    size: number;
}
export interface StatusHistoryRequest {
    filter: StatusHistoryFilter;
    historyKind: string;
    size: number;
    tag: string;
}
export interface StatusHistoryRequests {
    requests: StatusHistoryRequest[];
}
export interface StatusHistoryResult {
    error?: Error;
    history: History;
}
export interface StatusHistoryResults {
    results: StatusHistoryResult[];
}
export interface StatusParams {
    patterns: string[];
}
export interface StringResult {
    error?: Error;
    result: string;
}
export interface Tools {
    sha256?: string;
    size: number;
    url: string;
    version: Binary;
}
export interface UnitStatus {
    address?: string;
    "agent-status": DetailedStatus;
    charm: string;
    leader?: boolean;
    machine: string;
    "opened-ports": string[];
    "provider-id"?: string;
    "public-address": string;
    subordinates: Record<string, UnitStatus>;
    "workload-status": DetailedStatus;
    "workload-version": string;
}
export interface Value {
    "allocate-public-ip"?: boolean;
    arch?: string;
    container?: string;
    cores?: number;
    "cpu-power"?: number;
    "instance-type"?: string;
    mem?: number;
    "root-disk"?: number;
    "root-disk-source"?: string;
    spaces?: string[];
    tags?: string[];
    "virt-type"?: string;
    zones?: string[];
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**
  Client serves client-specific API methods.
*/
declare class ClientV2 implements Facade {
    static NAME: string;
    static VERSION: number;
    NAME: string;
    VERSION: number;
    _transport: Transport;
    _info: ConnectionInfo;
    constructor(transport: Transport, info: ConnectionInfo);
    /**
      APIHostPorts returns the API host/port addresses stored in state.
    */
    aPIHostPorts(params: any): Promise<APIHostPortsResult>;
    /**
      AbortCurrentUpgrade aborts and archives the current upgrade
      synchronisation record, if any.
    */
    abortCurrentUpgrade(params: any): Promise<any>;
    /**
      NOTE: AddCharm is deprecated as of juju 2.9 and charms facade version 3.
      Please discontinue use and move to the charms facade version.
  
      TODO: remove in juju 3.0
    */
    addCharm(params: AddCharm): Promise<any>;
    /**
      AddCharmWithAuthorization adds the given charm URL (which must include
      revision) to the model, if it does not exist yet. Local charms are not
      supported, only charm store URLs. See also AddLocalCharm().
  
      The authorization macaroon, args.CharmStoreMacaroon, may be omitted, in
      which case this call is equivalent to AddCharm.
  
      NOTE: AddCharmWithAuthorization is deprecated as of juju 2.9 and charms
      facade version 3. Please discontinue use and move to the charms facade
      version.
  
      TODO: remove in juju 3.0
    */
    addCharmWithAuthorization(params: AddCharmWithAuthorization): Promise<any>;
    /**
      AddMachines adds new machines with the supplied parameters.
    */
    addMachines(params: AddMachines): Promise<AddMachinesResults>;
    /**
      AddMachinesV2 adds new machines with the supplied parameters.
    */
    addMachinesV2(params: AddMachines): Promise<AddMachinesResults>;
    /**
      AgentVersion returns the current version that the API server is running.
    */
    agentVersion(params: any): Promise<AgentVersionResult>;
    /**
      CACert returns the certificate used to validate the state connection.
    */
    cACert(params: any): Promise<BytesResult>;
    /**
      DestroyMachines removes a given set of machines.
    */
    destroyMachines(params: DestroyMachines): Promise<any>;
    /**
      FindTools returns a List containing all tools matching the given parameters.
    */
    findTools(params: FindToolsParams): Promise<FindToolsResult>;
    /**
      FullStatus gives the information needed for juju status over the api
    */
    fullStatus(params: StatusParams): Promise<FullStatus>;
    /**
      GetBundleChanges returns the list of changes required to deploy the given
      bundle data. The changes are sorted by requirements, so that they can be
      applied in order.
      This call is deprecated, clients should use the GetChanges endpoint on the
      Bundle facade.
      Note: any new feature in the future like devices will never be supported here.
    */
    getBundleChanges(params: BundleChangesParams): Promise<BundleChangesResults>;
    /**
      GetModelConstraints returns the constraints for the model.
    */
    getModelConstraints(params: any): Promise<GetConstraintsResults>;
    /**
      InjectMachines injects a machine into state with provisioned status.
    */
    injectMachines(params: AddMachines): Promise<AddMachinesResults>;
    /**
      ModelGet implements the server-side part of the
      model-config CLI command.
    */
    modelGet(params: any): Promise<ModelConfigResults>;
    /**
      ModelInfo returns information about the current model.
    */
    modelInfo(params: any): Promise<ModelInfo>;
    /**
      ModelSet implements the server-side part of the
      set-model-config CLI command.
    */
    modelSet(params: ModelSet): Promise<any>;
    /**
      ModelUnset implements the server-side part of the
      set-model-config CLI command.
    */
    modelUnset(params: ModelUnset): Promise<any>;
    /**
      ModelUserInfo returns information on all users in the model.
    */
    modelUserInfo(params: any): Promise<ModelUserInfoResults>;
    /**
      PrivateAddress implements the server side of Client.PrivateAddress.
    */
    privateAddress(params: PrivateAddress): Promise<PrivateAddressResults>;
    /**
      ProvisioningScript returns a shell script that, when run,
      provisions a machine agent on the machine executing the script.
    */
    provisioningScript(params: ProvisioningScriptParams): Promise<ProvisioningScriptResult>;
    /**
      PublicAddress implements the server side of Client.PublicAddress.
    */
    publicAddress(params: PublicAddress): Promise<PublicAddressResults>;
    /**
      ResolveCharm resolves the best available charm URLs with series, for charm
      locations without a series specified.
  
      NOTE: ResolveCharms is deprecated as of juju 2.9 and charms facade version 3.
      Please discontinue use and move to the charms facade version.
  
      TODO: remove in juju 3.0
    */
    resolveCharms(params: ResolveCharms): Promise<ResolveCharmResults>;
    /**
      Resolved implements the server side of Client.Resolved.
    */
    resolved(params: Resolved): Promise<any>;
    /**
      RetryProvisioning marks a provisioning error as transient on the machines.
    */
    retryProvisioning(params: Entities): Promise<ErrorResults>;
    /**
      SLALevel returns the current sla level for the model.
    */
    sLALevel(params: any): Promise<StringResult>;
    /**
      SetModelAgentVersion sets the model agent version.
    */
    setModelAgentVersion(params: SetModelAgentVersion): Promise<any>;
    /**
      SetModelConstraints sets the constraints for the model.
    */
    setModelConstraints(params: SetConstraints): Promise<any>;
    /**
      SetSLALevel sets the sla level on the model.
    */
    setSLALevel(params: ModelSLA): Promise<any>;
    /**
      StatusHistory returns a slice of past statuses for several entities.
    */
    statusHistory(params: StatusHistoryRequests): Promise<StatusHistoryResults>;
    /**
      WatchAll initiates a watcher for entities in the connected model.
    */
    watchAll(params: any): Promise<AllWatcherId>;
}
export default ClientV2;