/**
  Juju Storage 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.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 AddStorageDetails {
    "storage-tags": string[];
}
export interface AddStorageResult {
    error?: Error;
    result?: AddStorageDetails;
}
export interface AddStorageResults {
    results: AddStorageResult[];
}
export interface BulkImportStorageParamsV2 {
    storage: ImportStorageParamsV2[];
}
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 FilesystemAttachmentDetails {
    FilesystemAttachmentInfo: FilesystemAttachmentInfo;
    life?: string;
    "mount-point"?: string;
    "read-only"?: boolean;
}
export interface FilesystemAttachmentInfo {
    "mount-point"?: string;
    "read-only"?: boolean;
}
export interface FilesystemDetails {
    "filesystem-tag": string;
    info: FilesystemInfo;
    life?: string;
    "machine-attachments"?: Record<string, FilesystemAttachmentDetails>;
    status: EntityStatus;
    storage?: StorageDetails;
    "unit-attachments"?: Record<string, FilesystemAttachmentDetails>;
    "volume-tag"?: string;
}
export interface FilesystemDetailsListResult {
    error?: Error;
    result?: FilesystemDetails[];
}
export interface FilesystemDetailsListResults {
    results?: FilesystemDetailsListResult[];
}
export interface FilesystemFilter {
    machines?: string[];
}
export interface FilesystemFilters {
    filters?: FilesystemFilter[];
}
export interface FilesystemInfo {
    "filesystem-id": string;
    pool: string;
    size: number;
}
export interface ImportStorageDetails {
    "storage-tag": string;
}
export interface ImportStorageParamsV2 {
    force?: boolean;
    kind: number;
    pool: string;
    "provider-id": string;
    "storage-name": string;
}
export interface ImportStorageResult {
    error?: Error;
    result?: ImportStorageDetails;
}
export interface ImportStorageResults {
    results: ImportStorageResult[];
}
export interface RemoveStorage {
    storage: RemoveStorageInstance[];
}
export interface RemoveStorageInstance {
    "destroy-attachments"?: boolean;
    "destroy-storage"?: boolean;
    force?: boolean;
    "max-wait"?: number;
    tag: string;
}
export interface StorageAddParams {
    name: string;
    storage: StorageConstraints;
    unit: string;
}
export interface StorageAttachmentDetails {
    life?: string;
    location?: string;
    "machine-tag": string;
    "storage-tag": string;
    "unit-tag": string;
}
export interface StorageAttachmentId {
    "storage-tag": string;
    "unit-tag": string;
}
export interface StorageAttachmentIds {
    ids: StorageAttachmentId[];
}
export interface StorageConstraints {
    count?: number;
    pool?: string;
    size?: number;
}
export interface StorageDetachmentParams {
    force?: boolean;
    ids: StorageAttachmentIds;
    "max-wait"?: number;
}
export interface StorageDetails {
    attachments?: Record<string, StorageAttachmentDetails>;
    kind: number;
    life?: string;
    "owner-tag": string;
    persistent: boolean;
    status: EntityStatus;
    "storage-tag": string;
}
export interface StorageDetailsListResult {
    error?: Error;
    result?: StorageDetails[];
}
export interface StorageDetailsListResults {
    results?: StorageDetailsListResult[];
}
export interface StorageDetailsResult {
    error?: Error;
    result?: StorageDetails;
}
export interface StorageDetailsResults {
    results?: StorageDetailsResult[];
}
export interface StorageFilter {
    [key: string]: AdditionalProperties;
}
export interface StorageFilters {
    filters?: StorageFilter[];
}
export interface StoragePool {
    attrs: AdditionalProperties;
    name: string;
    provider: string;
}
export interface StoragePoolArgs {
    pools: StoragePool[];
}
export interface StoragePoolDeleteArg {
    name: string;
}
export interface StoragePoolDeleteArgs {
    pools: StoragePoolDeleteArg[];
}
export interface StoragePoolFilter {
    names?: string[];
    providers?: string[];
}
export interface StoragePoolFilters {
    filters?: StoragePoolFilter[];
}
export interface StoragePoolsResult {
    error?: Error;
    "storage-pools"?: StoragePool[];
}
export interface StoragePoolsResults {
    results?: StoragePoolsResult[];
}
export interface StoragesAddParams {
    storages: StorageAddParams[];
}
export interface VolumeAttachmentDetails {
    VolumeAttachmentInfo: VolumeAttachmentInfo;
    "bus-address"?: string;
    "device-link"?: string;
    "device-name"?: string;
    life?: string;
    "plan-info"?: VolumeAttachmentPlanInfo;
    "read-only"?: boolean;
}
export interface VolumeAttachmentInfo {
    "bus-address"?: string;
    "device-link"?: string;
    "device-name"?: string;
    "plan-info"?: VolumeAttachmentPlanInfo;
    "read-only"?: boolean;
}
export interface VolumeAttachmentPlanInfo {
    "device-attributes"?: Record<string, string>;
    "device-type"?: string;
}
export interface VolumeDetails {
    info: VolumeInfo;
    life?: string;
    "machine-attachments"?: Record<string, VolumeAttachmentDetails>;
    status: EntityStatus;
    storage?: StorageDetails;
    "unit-attachments"?: Record<string, VolumeAttachmentDetails>;
    "volume-tag": string;
}
export interface VolumeDetailsListResult {
    error?: Error;
    result?: VolumeDetails[];
}
export interface VolumeDetailsListResults {
    results?: VolumeDetailsListResult[];
}
export interface VolumeFilter {
    machines?: string[];
}
export interface VolumeFilters {
    filters?: VolumeFilter[];
}
export interface VolumeInfo {
    "hardware-id"?: string;
    persistent: boolean;
    pool?: string;
    size: number;
    "volume-id": string;
    wwn?: string;
}
export interface AdditionalProperties {
    [key: string]: any;
}
/**

*/
declare class StorageV7 implements Facade {
    static NAME: string;
    static VERSION: number;
    NAME: string;
    VERSION: number;
    _transport: Transport;
    _info: ConnectionInfo;
    constructor(transport: Transport, info: ConnectionInfo);
    /**
  
    */
    addToUnit(params: StoragesAddParams): Promise<AddStorageResults>;
    /**
  
    */
    attach(params: StorageAttachmentIds): Promise<ErrorResults>;
    /**
  
    */
    createPool(params: StoragePoolArgs): Promise<ErrorResults>;
    /**
  
    */
    detachStorage(params: StorageDetachmentParams): Promise<ErrorResults>;
    /**
  
    */
    import(params: BulkImportStorageParamsV2): Promise<ImportStorageResults>;
    /**
  
    */
    listFilesystems(params: FilesystemFilters): Promise<FilesystemDetailsListResults>;
    /**
  
    */
    listPools(params: StoragePoolFilters): Promise<StoragePoolsResults>;
    /**
  
    */
    listStorageDetails(params: StorageFilters): Promise<StorageDetailsListResults>;
    /**
  
    */
    listVolumes(params: VolumeFilters): Promise<VolumeDetailsListResults>;
    /**
  
    */
    remove(params: RemoveStorage): Promise<ErrorResults>;
    /**
  
    */
    removePool(params: StoragePoolDeleteArgs): Promise<ErrorResults>;
    /**
  
    */
    storageDetails(params: Entities): Promise<StorageDetailsResults>;
    /**
  
    */
    updatePool(params: StoragePoolArgs): Promise<ErrorResults>;
}
export default StorageV7;