@canonical/jujulib/dist/api/facades/charms/CharmsV4.d.ts

Juju API client

/**
  Juju Charms version 4.
  This facade is available on:
    Models

  NOTE: This file was generated using the Juju schema
  from Juju 3.0-beta4 at the git SHA a13ab81a.
  Do not manually edit this file.
*/
import { ConnectionInfo, Transport } from "../../client.js";
import { Facade } from "../../types.js";
export interface AddCharmWithAuth {
    "charm-origin": CharmOrigin;
    force: boolean;
    macaroon: Macaroon;
    series: string;
    url: string;
}
export interface AddCharmWithOrigin {
    "charm-origin": CharmOrigin;
    force: boolean;
    series: string;
    url: string;
}
export interface ApplicationCharmPlacement {
    application: string;
    "charm-url": string;
}
export interface ApplicationCharmPlacements {
    placements: ApplicationCharmPlacement[];
}
export interface Charm {
    actions?: CharmActions;
    config: Record<string, CharmOption>;
    "lxd-profile"?: CharmLXDProfile;
    manifest?: CharmManifest;
    meta?: CharmMeta;
    metrics?: CharmMetrics;
    revision: number;
    url: string;
}
export interface CharmActionSpec {
    description: string;
    params: AdditionalProperties;
}
export interface CharmActions {
    specs?: Record<string, CharmActionSpec>;
}
export interface CharmBase {
    architectures?: string[];
    channel?: string;
    name?: string;
}
export interface CharmContainer {
    mounts?: CharmMount[];
    resource?: string;
}
export interface CharmDeployment {
    "min-version": string;
    mode: string;
    service: string;
    type: string;
}
export interface CharmDevice {
    CountMax: number;
    CountMin: number;
    Description: string;
    Name: string;
    Type: string;
}
export interface CharmLXDProfile {
    config: Record<string, string>;
    description: string;
    devices: Record<string, Record<string, string>>;
}
export interface CharmManifest {
    bases?: CharmBase[];
}
export interface CharmMeta {
    "assumes-expr"?: ExpressionTree;
    categories?: string[];
    containers?: Record<string, CharmContainer>;
    deployment?: CharmDeployment;
    description: string;
    devices?: Record<string, CharmDevice>;
    "extra-bindings"?: Record<string, string>;
    "min-juju-version"?: string;
    name: string;
    "payload-classes"?: Record<string, CharmPayloadClass>;
    peers?: Record<string, CharmRelation>;
    provides?: Record<string, CharmRelation>;
    requires?: Record<string, CharmRelation>;
    resources?: Record<string, CharmResourceMeta>;
    series?: string[];
    storage?: Record<string, CharmStorage>;
    subordinate: boolean;
    summary: string;
    tags?: string[];
    terms?: string[];
}
export interface CharmMetric {
    description: string;
    type: string;
}
export interface CharmMetrics {
    metrics: Record<string, CharmMetric>;
    plan: CharmPlan;
}
export interface CharmMount {
    location?: string;
    storage?: string;
}
export interface CharmOption {
    default?: AdditionalProperties;
    description?: string;
    type: string;
}
export interface CharmOrigin {
    architecture?: string;
    branch?: string;
    hash?: string;
    id: string;
    "instance-key"?: string;
    os?: string;
    revision?: number;
    risk?: string;
    series?: string;
    source: string;
    track?: string;
    type: string;
}
export interface CharmOriginResult {
    "charm-origin": CharmOrigin;
    error?: Error;
}
export interface CharmPayloadClass {
    name: string;
    type: string;
}
export interface CharmPlan {
    required: boolean;
}
export interface CharmRelation {
    interface: string;
    limit: number;
    name: string;
    optional: boolean;
    role: string;
    scope: string;
}
export interface CharmResource {
    description?: string;
    fingerprint: number[];
    name: string;
    origin: string;
    path: string;
    revision: number;
    size: number;
    type: string;
}
export interface CharmResourceMeta {
    description: string;
    name: string;
    path: string;
    type: string;
}
export interface CharmResourceResult {
    CharmResource: CharmResource;
    ErrorResult: ErrorResult;
    description?: string;
    error?: Error;
    fingerprint: number[];
    name: string;
    origin: string;
    path: string;
    revision: number;
    size: number;
    type: string;
}
export interface CharmResourcesResults {
    results: CharmResourceResult[][];
}
export interface CharmStorage {
    "count-max": number;
    "count-min": number;
    description: string;
    location?: string;
    "minimum-size": number;
    name: string;
    properties?: string[];
    "read-only": boolean;
    shared: boolean;
    type: string;
}
export interface CharmURL {
    url: string;
}
export interface CharmURLAndOrigin {
    "charm-origin": CharmOrigin;
    "charm-url": string;
    macaroon?: Macaroon;
}
export interface CharmURLAndOrigins {
    entities: CharmURLAndOrigin[];
}
export interface CharmsList {
    names: string[];
}
export interface CharmsListResult {
    "charm-urls": string[];
}
export interface DownloadInfoResult {
    "charm-origin": CharmOrigin;
    url: string;
}
export interface DownloadInfoResults {
    results: DownloadInfoResult[];
}
export interface Error {
    code: string;
    info?: AdditionalProperties;
    message: string;
}
export interface ErrorResult {
    error?: Error;
}
export interface ErrorResults {
    results: ErrorResult[];
}
export interface ExpressionTree {
    Expression: AdditionalProperties;
}
export interface IsMeteredResult {
    metered: boolean;
}
export interface Macaroon {
    [key: string]: AdditionalProperties;
}
export interface ResolveCharmWithChannel {
    "charm-origin": CharmOrigin;
    reference: string;
    "switch-charm"?: boolean;
}
export interface ResolveCharmWithChannelResult {
    "charm-origin": CharmOrigin;
    error?: Error;
    "supported-series": string[];
    url: string;
}
export interface ResolveCharmWithChannelResults {
    Results: ResolveCharmWithChannelResult[];
}
export interface ResolveCharmsWithChannel {
    macaroon?: Macaroon;
    resolve: ResolveCharmWithChannel[];
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**
  API implements the charms interface and is the concrete
  implementation of the API end point.
*/
declare class CharmsV4 implements Facade {
    static NAME: string;
    static VERSION: number;
    NAME: string;
    VERSION: number;
    _transport: Transport;
    _info: ConnectionInfo;
    constructor(transport: Transport, info: ConnectionInfo);
    /**
      AddCharm adds the given charm URL (which must include revision) to the
      environment, if it does not exist yet. Local charms are not supported,
      only charm store and charm hub URLs. See also AddLocalCharm().
    */
    addCharm(params: AddCharmWithOrigin): Promise<CharmOriginResult>;
    /**
      AddCharmWithAuthorization adds the given charm URL (which must include
      revision) to the environment, if it does not exist yet. Local charms are
      not supported, only charm store and charm hub URLs. See also AddLocalCharm().
  
      The authorization macaroon, args.CharmStoreMacaroon, may be
      omitted, in which case this call is equivalent to AddCharm.
    */
    addCharmWithAuthorization(params: AddCharmWithAuth): Promise<CharmOriginResult>;
    /**
      CharmInfo returns information about the requested charm.
    */
    charmInfo(params: CharmURL): Promise<Charm>;
    /**
      CheckCharmPlacement checks if a charm is allowed to be placed with in a
      given application.
    */
    checkCharmPlacement(params: ApplicationCharmPlacements): Promise<ErrorResults>;
    /**
      GetDownloadInfos attempts to get the bundle corresponding to the charm url
      and origin.
    */
    getDownloadInfos(params: CharmURLAndOrigins): Promise<DownloadInfoResults>;
    /**
      IsMetered returns whether or not the charm is metered.
    */
    isMetered(params: CharmURL): Promise<IsMeteredResult>;
    /**
      List returns a list of charm URLs currently in the state.
      If supplied parameter contains any names, the result will
      be filtered to return only the charms with supplied names.
    */
    list(params: CharmsList): Promise<CharmsListResult>;
    /**
      ListCharmResources returns a series of resources for a given charm.
    */
    listCharmResources(params: CharmURLAndOrigins): Promise<CharmResourcesResults>;
    /**
      ResolveCharms resolves the given charm URLs with an optionally specified
      preferred channel.  Channel provided via CharmOrigin.
    */
    resolveCharms(params: ResolveCharmsWithChannel): Promise<ResolveCharmWithChannelResults>;
}
export default CharmsV4;