/**
  Juju MigrationTarget version 2.
  This facade is available on:
    Controllers

  NOTE: This file was generated using the Juju schema
  from Juju 3.2 at the git SHA 3a098707a1.
  Do not manually edit this file.
*/
import { ConnectionInfo, Transport } from "../../client.js";
import { Facade } from "../../types.js";
export interface ActivateModelArgs {
    "controller-alias"?: string;
    "controller-tag": string;
    "cross-model-uuids": string[];
    "model-tag": string;
    "source-api-addrs": string[];
    "source-ca-cert": string;
}
export interface AdoptResourcesArgs {
    "model-tag": string;
    "source-controller-version": Number;
}
export interface BytesResult {
    result: number[];
}
export interface Error {
    code: string;
    info?: AdditionalProperties;
    message: string;
}
export interface ErrorResult {
    error?: Error;
}
export interface ErrorResults {
    results: ErrorResult[];
}
export interface MigrationModelInfo {
    "agent-version": string;
    "controller-agent-version": Number;
    name: string;
    "owner-tag": string;
    uuid: string;
}
export interface ModelArgs {
    "model-tag": string;
}
export interface Number {
    Build: number;
    Major: number;
    Minor: number;
    Patch: number;
    Tag: string;
}
export interface SerializedModel {
    bytes: number[];
    charms: string[];
    resources: SerializedModelResource[];
    tools: SerializedModelTools[];
}
export interface SerializedModelResource {
    application: string;
    "application-revision": SerializedModelResourceRevision;
    "charmstore-revision": SerializedModelResourceRevision;
    name: string;
    "unit-revisions": Record<string, SerializedModelResourceRevision>;
}
export interface SerializedModelResourceRevision {
    description: string;
    fingerprint: string;
    origin: string;
    path: string;
    revision: number;
    size: number;
    timestamp: string;
    type: string;
    username?: string;
}
export interface SerializedModelTools {
    uri: string;
    version: string;
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**
  API implements the API required for the model migration
  master worker when communicating with the target controller.
*/
declare class MigrationTargetV2 implements Facade {
    static NAME: string;
    static VERSION: number;
    NAME: string;
    VERSION: number;
    _transport: Transport;
    _info: ConnectionInfo;
    constructor(transport: Transport, info: ConnectionInfo);
    /**
      Abort removes the specified model from the database. It is an error to
      attempt to Abort a model that has a migration mode other than importing.
    */
    abort(params: ModelArgs): Promise<any>;
    /**
      Activate sets the migration mode of the model to "none", meaning it
      is ready for use. It is an error to attempt to Abort a model that
      has a migration mode other than importing. It also adds any required
      external controller records for those controllers hosting offers used
      by the model.
    */
    activate(params: ActivateModelArgs): Promise<any>;
    /**
      AdoptResources asks the cloud provider to update the controller
      tags for a model's resources. This prevents the resources from
      being destroyed if the source controller is destroyed after the
      model is migrated away.
    */
    adoptResources(params: AdoptResourcesArgs): Promise<any>;
    /**
      CACert returns the certificate used to validate the state connection.
    */
    cACert(params: any): Promise<BytesResult>;
    /**
      CheckMachines compares the machines in state with the ones reported
      by the provider and reports any discrepancies.
    */
    checkMachines(params: ModelArgs): Promise<ErrorResults>;
    /**
      Import takes a serialized Juju model, deserializes it, and
      recreates it in the receiving controller.
    */
    import(params: SerializedModel): Promise<any>;
    /**
      LatestLogTime returns the time of the most recent log record
      received by the logtransfer endpoint. This can be used as the start
      point for streaming logs from the source if the transfer was
      interrupted.
  
      For performance reasons, not every time is tracked, so if the
      target controller died during the transfer the latest log time
      might be up to 2 minutes earlier. If the transfer was interrupted
      in some other way (like the source controller going away or a
      network partition) the time will be up-to-date.
  
      Log messages are assumed to be sent in time order (which is how
      debug-log emits them). If that isn't the case then this mechanism
      can't be used to avoid duplicates when logtransfer is restarted.
  
      Returns the zero time if no logs have been transferred.
    */
    latestLogTime(params: ModelArgs): Promise<string>;
    /**
      Prechecks ensure that the target controller is ready to accept a
      model migration.
    */
    prechecks(params: MigrationModelInfo): Promise<any>;
}
export default MigrationTargetV2;