/**
  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 type { JujuRequest } from "../../../generator/interfaces.js";
import { ConnectionInfo, Transport } from "../../client.js";
import { Facade } from "../../types.js";
import { autoBind } from "../../utils.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;
}

/**

*/
class StorageV7 implements Facade {
  static NAME = "Storage";
  static VERSION = 7;

  NAME = "Storage";
  VERSION = 7;

  _transport: Transport;
  _info: ConnectionInfo;

  constructor(transport: Transport, info: ConnectionInfo) {
    this._transport = transport;
    this._info = info;

    // Automatically bind all methods to instances.
    autoBind(this);
  }
  /**

  */
  addToUnit(params: StoragesAddParams): Promise<AddStorageResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "AddToUnit",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  attach(params: StorageAttachmentIds): Promise<ErrorResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "Attach",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  createPool(params: StoragePoolArgs): Promise<ErrorResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "CreatePool",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  detachStorage(params: StorageDetachmentParams): Promise<ErrorResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "DetachStorage",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  import(params: BulkImportStorageParamsV2): Promise<ImportStorageResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "Import",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  listFilesystems(
    params: FilesystemFilters
  ): Promise<FilesystemDetailsListResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "ListFilesystems",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  listPools(params: StoragePoolFilters): Promise<StoragePoolsResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "ListPools",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  listStorageDetails(
    params: StorageFilters
  ): Promise<StorageDetailsListResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "ListStorageDetails",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  listVolumes(params: VolumeFilters): Promise<VolumeDetailsListResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "ListVolumes",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  remove(params: RemoveStorage): Promise<ErrorResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "Remove",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  removePool(params: StoragePoolDeleteArgs): Promise<ErrorResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "RemovePool",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  storageDetails(params: Entities): Promise<StorageDetailsResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "StorageDetails",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }

  /**

  */
  updatePool(params: StoragePoolArgs): Promise<ErrorResults> {
    return new Promise((resolve, reject) => {
      const req: JujuRequest = {
        type: "Storage",
        request: "UpdatePool",
        version: 7,
        params: params,
      };

      this._transport.write(req, resolve, reject);
    });
  }
}

export default StorageV7;