/**
  Juju Application version 22.
  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.6.14 at the git SHA b08ad63.
  Do not manually edit this file.
*/
import { ConnectionInfo, Transport } from "../../client.js";
import { Facade } from "../../types.js";
export interface AddApplicationUnits {
    application: string;
    "attach-storage"?: string[];
    "num-units": number;
    placement: Placement[];
    policy?: string;
}
export interface AddApplicationUnitsResults {
    units: string[];
}
export interface AddRelation {
    endpoints: string[];
    "via-cidrs"?: string[];
}
export interface AddRelationResults {
    endpoints: Record<string, CharmRelation>;
}
export interface ApplicationCharmRelations {
    application: string;
}
export interface ApplicationCharmRelationsResults {
    "charm-relations": string[];
}
export interface ApplicationConfigUnsetArgs {
    Args: ApplicationUnset[];
}
export interface ApplicationConstraint {
    constraints: Value;
    error?: Error;
}
export interface ApplicationDeploy {
    Force: boolean;
    application: string;
    "attach-storage"?: string[];
    channel: string;
    "charm-origin"?: CharmOrigin;
    "charm-url": string;
    config?: Record<string, string>;
    "config-yaml": string;
    constraints: Value;
    devices?: Record<string, Constraints>;
    "endpoint-bindings"?: Record<string, string>;
    "num-units": number;
    placement?: Placement[];
    policy?: string;
    resources?: Record<string, string>;
    storage?: Record<string, Constraints>;
}
export interface ApplicationExpose {
    application: string;
    "exposed-endpoints"?: Record<string, ExposedEndpoint>;
}
export interface ApplicationGet {
    application: string;
    branch: string;
}
export interface ApplicationGetArgs {
    args: ApplicationGet[];
}
export interface ApplicationGetConfigResults {
    Results: ConfigResult[];
}
export interface ApplicationGetConstraintsResults {
    results: ApplicationConstraint[];
}
export interface ApplicationGetResults {
    application: string;
    "application-config"?: AdditionalProperties;
    base: Base;
    channel: string;
    charm: string;
    config: AdditionalProperties;
    constraints: Value;
    "endpoint-bindings"?: Record<string, string>;
}
export interface ApplicationInfoResult {
    error?: Error;
    result?: ApplicationResult;
}
export interface ApplicationInfoResults {
    results: ApplicationInfoResult[];
}
export interface ApplicationMergeBindings {
    "application-tag": string;
    bindings: Record<string, string>;
    force: boolean;
}
export interface ApplicationMergeBindingsArgs {
    args: ApplicationMergeBindings[];
}
export interface ApplicationMetricCredential {
    application: string;
    "metrics-credentials": number[];
}
export interface ApplicationMetricCredentials {
    creds: ApplicationMetricCredential[];
}
export interface ApplicationOfferDetailsV5 {
    "application-description": string;
    endpoints?: RemoteEndpoint[];
    "offer-name": string;
    "offer-url": string;
    "offer-uuid": string;
    "source-model-tag": string;
    users?: OfferUserDetails[];
}
export interface ApplicationResult {
    base?: Base;
    channel?: string;
    charm?: string;
    constraints?: Value;
    "endpoint-bindings"?: Record<string, string>;
    exposed: boolean;
    "exposed-endpoints"?: Record<string, ExposedEndpoint>;
    life: string;
    principal: boolean;
    remote: boolean;
    tag: string;
}
export interface ApplicationSetCharm {
    application: string;
    channel: string;
    "charm-origin"?: CharmOrigin;
    "charm-url": string;
    "config-settings"?: Record<string, string>;
    "config-settings-yaml"?: string;
    "endpoint-bindings"?: Record<string, string>;
    force: boolean;
    "force-base": boolean;
    "force-units": boolean;
    generation: string;
    "resource-ids"?: Record<string, string>;
    "storage-constraints"?: Record<string, StorageConstraints>;
}
export interface ApplicationStorageGetResult {
    Error: Error;
    "storage-constraints": Record<string, StorageConstraints>;
}
export interface ApplicationStorageGetResults {
    results: ApplicationStorageGetResult[];
}
export interface ApplicationStorageUpdate {
    "application-tag": string;
    "storage-constraints": Record<string, StorageConstraints>;
}
export interface ApplicationStorageUpdateRequest {
    "storage-updates": ApplicationStorageUpdate[];
}
export interface ApplicationUnexpose {
    application: string;
    "exposed-endpoints": string[];
}
export interface ApplicationUnset {
    application: string;
    branch: string;
    options: string[];
}
export interface ApplicationsDeploy {
    applications: ApplicationDeploy[];
}
export interface Base {
    channel: string;
    name: string;
}
export interface CharmOrigin {
    architecture?: string;
    base?: Base;
    branch?: string;
    hash?: string;
    id: string;
    "instance-key"?: string;
    revision?: number;
    risk?: string;
    source: string;
    track?: string;
    type: string;
}
export interface CharmRelation {
    interface: string;
    limit: number;
    name: string;
    optional: boolean;
    role: string;
    scope: string;
}
export interface CharmURLOriginResult {
    "charm-origin": CharmOrigin;
    error?: Error;
    url: string;
}
export interface ConfigResult {
    config: AdditionalProperties;
    error?: Error;
}
export interface ConfigSet {
    application: string;
    config: Record<string, string>;
    "config-yaml": string;
    generation: string;
}
export interface ConfigSetArgs {
    Args: ConfigSet[];
}
export interface Constraints {
    Count: number;
    Pool: string;
    Size: number;
}
export interface ConsumeApplicationArgV5 {
    ApplicationOfferDetailsV5: ApplicationOfferDetailsV5;
    "application-alias"?: string;
    "application-description": string;
    endpoints?: RemoteEndpoint[];
    "external-controller"?: ExternalControllerInfo;
    macaroon?: Macaroon;
    "offer-name": string;
    "offer-url": string;
    "offer-uuid": string;
    "source-model-tag": string;
    users?: OfferUserDetails[];
}
export interface ConsumeApplicationArgsV5 {
    args?: ConsumeApplicationArgV5[];
}
export interface DeployFromRepositoryArg {
    ApplicationName: string;
    AttachStorage: string[];
    CharmName: string;
    ConfigYAML: string;
    Cons: Value;
    Devices: Record<string, Constraints>;
    DryRun: boolean;
    Placement: Placement[];
    Storage: Record<string, Constraints>;
    Trust: boolean;
    base?: Base;
    channel?: string;
    "endpoint-bindings"?: Record<string, string>;
    force?: boolean;
    "num-units"?: number;
    resources?: Record<string, string>;
    revision?: number;
}
export interface DeployFromRepositoryArgs {
    Args: DeployFromRepositoryArg[];
}
export interface DeployFromRepositoryInfo {
    architecture: string;
    base?: Base;
    channel: string;
    "effective-channel"?: string;
    name: string;
    revision: number;
}
export interface DeployFromRepositoryResult {
    Errors: Error[];
    Info: DeployFromRepositoryInfo;
    PendingResourceUploads: PendingResourceUpload[];
}
export interface DeployFromRepositoryResults {
    Results: DeployFromRepositoryResult[];
}
export interface DestroyApplicationInfo {
    "destroyed-storage"?: Entity[];
    "destroyed-units"?: Entity[];
    "detached-storage"?: Entity[];
}
export interface DestroyApplicationParams {
    "application-tag": string;
    "destroy-storage"?: boolean;
    "dry-run"?: boolean;
    force: boolean;
    "max-wait"?: number;
}
export interface DestroyApplicationResult {
    error?: Error;
    info?: DestroyApplicationInfo;
}
export interface DestroyApplicationResults {
    results?: DestroyApplicationResult[];
}
export interface DestroyApplicationsParams {
    applications: DestroyApplicationParams[];
}
export interface DestroyConsumedApplicationParams {
    "application-tag": string;
    force?: boolean;
    "max-wait"?: number;
}
export interface DestroyConsumedApplicationsParams {
    applications: DestroyConsumedApplicationParams[];
}
export interface DestroyRelation {
    endpoints?: string[];
    force?: boolean;
    "max-wait"?: number;
    "relation-id": number;
}
export interface DestroyUnitInfo {
    "destroyed-storage"?: Entity[];
    "detached-storage"?: Entity[];
}
export interface DestroyUnitParams {
    "destroy-storage"?: boolean;
    "dry-run"?: boolean;
    force?: boolean;
    "max-wait"?: number;
    "unit-tag": string;
}
export interface DestroyUnitResult {
    error?: Error;
    info?: DestroyUnitInfo;
}
export interface DestroyUnitResults {
    results?: DestroyUnitResult[];
}
export interface DestroyUnitsParams {
    units: DestroyUnitParams[];
}
export interface EndpointRelationData {
    ApplicationData: AdditionalProperties;
    "cross-model": boolean;
    endpoint: string;
    "related-endpoint": string;
    "relation-id": number;
    "unit-relation-data": Record<string, RelationData>;
}
export interface Entities {
    entities: Entity[];
}
export interface Entity {
    tag: 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 ExternalControllerInfo {
    addrs: string[];
    "ca-cert": string;
    "controller-alias": string;
    "controller-tag": string;
}
export interface Macaroon {
    [key: string]: AdditionalProperties;
}
export interface OfferUserDetails {
    access: string;
    "display-name": string;
    user: string;
}
export interface PendingResourceUpload {
    Filename: string;
    Name: string;
    Type: string;
}
export interface Placement {
    directive: string;
    scope: string;
}
export interface RelationData {
    InScope: boolean;
    UnitData: AdditionalProperties;
}
export interface RelationSuspendedArg {
    message: string;
    "relation-id": number;
    suspended: boolean;
}
export interface RelationSuspendedArgs {
    args: RelationSuspendedArg[];
}
export interface RemoteEndpoint {
    interface: string;
    limit: number;
    name: string;
    role: string;
}
export interface ScaleApplicationInfo {
    "num-units": number;
}
export interface ScaleApplicationParamsV2 {
    "application-tag": string;
    "attach-storage"?: string[];
    force: boolean;
    scale: number;
    "scale-change"?: number;
}
export interface ScaleApplicationResult {
    error?: Error;
    info?: ScaleApplicationInfo;
}
export interface ScaleApplicationResults {
    results?: ScaleApplicationResult[];
}
export interface ScaleApplicationsParamsV2 {
    applications: ScaleApplicationParamsV2[];
}
export interface SetConstraints {
    application: string;
    constraints: Value;
}
export interface StorageConstraints {
    count?: number;
    pool?: string;
    size?: number;
}
export interface StringResult {
    error?: Error;
    result: string;
}
export interface UnitInfoResult {
    error?: Error;
    result?: UnitResult;
}
export interface UnitInfoResults {
    results: UnitInfoResult[];
}
export interface UnitResult {
    address?: string;
    charm: string;
    leader?: boolean;
    life?: string;
    machine?: string;
    "opened-ports": string[];
    "provider-id"?: string;
    "public-address"?: string;
    "relation-data"?: EndpointRelationData[];
    tag: string;
    "workload-version": string;
}
export interface UnitsResolved {
    all?: boolean;
    retry?: boolean;
    tags?: Entities;
}
export interface UpdateChannelArg {
    channel: string;
    force: boolean;
    tag: Entity;
}
export interface UpdateChannelArgs {
    args: UpdateChannelArg[];
}
export interface Value {
    "allocate-public-ip"?: boolean;
    arch?: string;
    container?: string;
    cores?: number;
    "cpu-power"?: number;
    "image-id"?: string;
    "instance-role"?: string;
    "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;
}
/**

*/
declare class ApplicationV22 implements Facade {
    static NAME: string;
    static VERSION: number;
    NAME: string;
    VERSION: number;
    _transport: Transport;
    _info: ConnectionInfo;
    constructor(transport: Transport, info: ConnectionInfo);
    /**
  
    */
    addRelation(params: AddRelation): Promise<AddRelationResults>;
    /**
  
    */
    addUnits(params: AddApplicationUnits): Promise<AddApplicationUnitsResults>;
    /**
  
    */
    applicationsInfo(params: Entities): Promise<ApplicationInfoResults>;
    /**
  
    */
    charmConfig(params: ApplicationGetArgs): Promise<ApplicationGetConfigResults>;
    /**
  
    */
    charmRelations(params: ApplicationCharmRelations): Promise<ApplicationCharmRelationsResults>;
    /**
  
    */
    consume(params: ConsumeApplicationArgsV5): Promise<ErrorResults>;
    /**
  
    */
    deploy(params: ApplicationsDeploy): Promise<ErrorResults>;
    /**
  
    */
    deployFromRepository(params: DeployFromRepositoryArgs): Promise<DeployFromRepositoryResults>;
    /**
  
    */
    destroyApplication(params: DestroyApplicationsParams): Promise<DestroyApplicationResults>;
    /**
  
    */
    destroyConsumedApplications(params: DestroyConsumedApplicationsParams): Promise<ErrorResults>;
    /**
  
    */
    destroyRelation(params: DestroyRelation): Promise<any>;
    /**
  
    */
    destroyUnit(params: DestroyUnitsParams): Promise<DestroyUnitResults>;
    /**
  
    */
    expose(params: ApplicationExpose): Promise<any>;
    /**
  
    */
    get(params: ApplicationGet): Promise<ApplicationGetResults>;
    /**
  
    */
    getApplicationStorage(params: Entities): Promise<ApplicationStorageGetResults>;
    /**
  
    */
    getCharmURLOrigin(params: ApplicationGet): Promise<CharmURLOriginResult>;
    /**
  
    */
    getConfig(params: Entities): Promise<ApplicationGetConfigResults>;
    /**
  
    */
    getConstraints(params: Entities): Promise<ApplicationGetConstraintsResults>;
    /**
  
    */
    leader(params: Entity): Promise<StringResult>;
    /**
  
    */
    mergeBindings(params: ApplicationMergeBindingsArgs): Promise<ErrorResults>;
    /**
  
    */
    resolveUnitErrors(params: UnitsResolved): Promise<ErrorResults>;
    /**
  
    */
    scaleApplications(params: ScaleApplicationsParamsV2): Promise<ScaleApplicationResults>;
    /**
  
    */
    setCharm(params: ApplicationSetCharm): Promise<any>;
    /**
  
    */
    setConfigs(params: ConfigSetArgs): Promise<ErrorResults>;
    /**
  
    */
    setConstraints(params: SetConstraints): Promise<any>;
    /**
  
    */
    setMetricCredentials(params: ApplicationMetricCredentials): Promise<ErrorResults>;
    /**
  
    */
    setRelationsSuspended(params: RelationSuspendedArgs): Promise<ErrorResults>;
    /**
  
    */
    unexpose(params: ApplicationUnexpose): Promise<any>;
    /**
  
    */
    unitsInfo(params: Entities): Promise<UnitInfoResults>;
    /**
  
    */
    unsetApplicationsConfig(params: ApplicationConfigUnsetArgs): Promise<ErrorResults>;
    /**
  
    */
    updateApplicationBase(params: UpdateChannelArgs): Promise<ErrorResults>;
    /**
  
    */
    updateApplicationStorage(params: ApplicationStorageUpdateRequest): Promise<ErrorResults>;
}
export default ApplicationV22;