@alauda-fe/storage 0.0.9 → 0.0.10

package/esm2022/lib/types/k8s.mjs

@@ -1,2 +1,36 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,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
+const CephResourceConfigurationKeys = [
+    'mgr',
+    'mon',
+    'osd',
+    'rbdmirror',
+    'prepareosd',
+    'crashcollector',
+    'cleanup',
+];
+const CephPlacementConfigurationKeys = [
+    'mgr',
+    'mon',
+    'rbdmirror',
+    'cleanup',
+    'all',
+    'osd',
+];
+export var TopolvmClusterStorageDeviceClassStatusEnum;
+(function (TopolvmClusterStorageDeviceClassStatusEnum) {
+    TopolvmClusterStorageDeviceClassStatusEnum["AVAILABLE"] = "available";
+    TopolvmClusterStorageDeviceClassStatusEnum["NOT_AVAILABLE"] = "not_available";
+})(TopolvmClusterStorageDeviceClassStatusEnum || (TopolvmClusterStorageDeviceClassStatusEnum = {}));
+// MinioCluster
+export var HealthStatus;
+(function (HealthStatus) {
+    HealthStatus["GREEN"] = "green";
+    HealthStatus["YELLOW"] = "yellow";
+    HealthStatus["RED"] = "red";
+})(HealthStatus || (HealthStatus = {}));
+export var PoolState;
+(function (PoolState) {
+    PoolState["POOL_NOT_CREATED"] = "PoolNotCreated";
+    PoolState["POOL_CREATED"] = "PoolCreated";
+    PoolState["POOL_INITIALIZED"] = "PoolInitialized";
+})(PoolState || (PoolState = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s.js","sourceRoot":"","sources":["../../../../../../modules/storage/src/lib/types/k8s.ts"],"names":[],"mappings":"AAiLA,MAAM,6BAA6B,GAAG;IACpC,KAAK;IACL,KAAK;IACL,KAAK;IACL,WAAW;IACX,YAAY;IACZ,gBAAgB;IAChB,SAAS;CACD,CAAC;AAiEX,MAAM,8BAA8B,GAAG;IACrC,KAAK;IACL,KAAK;IACL,WAAW;IACX,SAAS;IACT,KAAK;IACL,KAAK;CACG,CAAC;AAmKX,MAAM,CAAN,IAAY,0CAGX;AAHD,WAAY,0CAA0C;IACpD,qEAAuB,CAAA;IACvB,6EAA+B,CAAA;AACjC,CAAC,EAHW,0CAA0C,KAA1C,0CAA0C,QAGrD;AA8BD,eAAe;AAEf,MAAM,CAAN,IAAY,YAIX;AAJD,WAAY,YAAY;IACtB,+BAAe,CAAA;IACf,iCAAiB,CAAA;IACjB,2BAAW,CAAA;AACb,CAAC,EAJW,YAAY,KAAZ,YAAY,QAIvB;AAED,MAAM,CAAN,IAAY,SAIX;AAJD,WAAY,SAAS;IACnB,gDAAmC,CAAA;IACnC,yCAA4B,CAAA;IAC5B,iDAAoC,CAAA;AACtC,CAAC,EAJW,SAAS,KAAT,SAAS,QAIpB","sourcesContent":["import {\n  AccessMode,\n  Condition,\n  KubernetesResource,\n  StringMap,\n  Affinity,\n  ResourceRequirements,\n} from '@alauda-fe/common';\n\nimport {\n  ReclaimPolicy,\n  StorageProvisioner,\n  VolumeBindingMode,\n} from './commons';\n\nexport interface VolumeSnapshotClass extends KubernetesResource {\n  driver: string;\n  parameters?: StringMap;\n  deletionPolicy?: string;\n}\n\nexport interface VolumeSnapshot extends KubernetesResource {\n  spec: VolumeSnapshotSpec;\n  status?: {\n    boundVolumeSnapshotContentName?: string;\n    readyToUse?: boolean;\n    error?: string;\n    restoreSize?: string;\n  };\n}\n\nexport interface VolumeSnapshotSpec {\n  volumeSnapshotClassName: string;\n  source?: {\n    persistentVolumeClaimName?: string;\n  };\n}\n\nexport interface StorageClass extends KubernetesResource {\n  apiVersion: 'storage.k8s.io/v1';\n  kind: 'StorageClass';\n  mountOptions?: string[];\n  parameters?: StringMap;\n  provisioner?: StorageProvisioner;\n  reclaimPolicy?: ReclaimPolicy;\n  volumeBindingMode?: VolumeBindingMode;\n  allowVolumeExpansion?: boolean;\n}\n\nexport interface BucketClass extends KubernetesResource {\n  kind: 'BucketClass';\n  driverName: StorageProvisioner;\n  deletionPolicy?: ReclaimPolicy;\n  isDefaultBucketClass?: boolean;\n  parameters?: StringMap;\n  protocol?: {\n    s3: {\n      region: string;\n      signatureVersion: string;\n    };\n  };\n}\n\nexport type CommonStorageClass = StorageClass | BucketClass;\n\nexport type CommonStorageClassKind = CommonStorageClass extends {\n  kind: infer K;\n}\n  ? K\n  : never;\n\nexport interface CephFSPersistentVolumeSource {\n  monitors: string[];\n  path?: string;\n  secretRef: SecretReference;\n  user: string;\n}\n\nexport interface SecretReference {\n  name: string;\n  namespace: string;\n}\n\nexport interface PersistentVolumeSpec extends PersistentVolumeSpecMeta {\n  accessModes: [AccessMode];\n  // null 表示使用默认 sc\n  // \"\" 或不写该字段表示不设置存储类\n  storageClassName?: string;\n}\n\nexport interface PersistentVolume extends KubernetesResource {\n  apiVersion: string;\n  kind: string;\n  spec: PersistentVolumeSpec;\n  status?: {\n    phase: string;\n  };\n}\n\nexport interface PersistentVolumeSpecMeta {\n  capacity: {\n    storage: string;\n  };\n  claimRef?: {\n    apiVersion: string;\n    kind: 'PersistentVolumeClaim';\n    name: string;\n    namespace: string;\n    uid: string;\n  };\n  persistentVolumeReclaimPolicy: 'Retain' | 'Delete';\n  hostPath?: {\n    path: string;\n  };\n  nfs?: {\n    server: string;\n    path: string;\n  };\n  cephfs?: CephFSPersistentVolumeSource;\n  mountOptions?: string[];\n  csi?: {\n    driver?: string;\n    readOnly?: boolean;\n    /** 该字段由UI生成， 需保证集群唯一， 可采用uuid */\n    volumeHandle?: string;\n    volumeAttributes: {\n      /** nfs 服务端地址 */\n      server: string;\n      /** nfs 服务端fs目录 */\n      share: string;\n    };\n  };\n}\n\nexport interface VolumeClaimTemplate extends KubernetesResource {\n  spec: {\n    accessModes: string[];\n    resources: {\n      requests: {\n        storage: string;\n      };\n    };\n    storageClassName: string;\n  };\n}\n\nexport interface CephClusterNetwork {\n  ipFamily?: string;\n  provider?: string;\n}\n\nexport interface CephClusterStatus {\n  ceph: {\n    health: string;\n    lastChecked: string;\n    details: unknown;\n    capacity?: {\n      bytesAvailable: number;\n      bytesTotal: number;\n      bytesUsed: number;\n      lastUpdated: string;\n    };\n  };\n  conditions: Condition[];\n  message: string;\n  phase: string;\n  state: string;\n  version: {\n    image: string;\n    version: string;\n  };\n  storage: {\n    deviceClasses: Array<{ name: string }>;\n  };\n  network: CephClusterNetwork;\n}\n\nconst CephResourceConfigurationKeys = [\n  'mgr',\n  'mon',\n  'osd',\n  'rbdmirror',\n  'prepareosd',\n  'crashcollector',\n  'cleanup',\n] as const;\n\nexport interface CephDashBoardSpec {\n  enabled: boolean;\n  urlPrefix?: string;\n  port?: number;\n  ssl?: boolean;\n}\n\n// https://github.com/rook/rook/blob/master/Documentation/CRDs/Cluster/stretch-cluster.md\nexport interface StretchCluster {\n  failureDomainLabel: string;\n  subFailureDomain: string;\n  zones: Array<{\n    name: string;\n    arbiter?: boolean;\n  }>;\n}\n\nexport interface CephMonSettings {\n  count: number;\n  allowMultiplePerNode?: boolean;\n  volumeClaimTemplate?: PersistentVolumeSpec;\n  stretchCluster?: StretchCluster;\n}\n\nexport interface CephMgrSettings {\n  modules: Array<{\n    name: string;\n    enabled: boolean;\n  }>;\n  count?: number;\n}\n\nexport interface CephOsdConfiguration {\n  metadataDevice?: string;\n  storeType?: string;\n  databaseSizeMB?: number;\n  walSizeMB?: number;\n  osdsPerDevice?: number;\n  encryptedDevice?: boolean;\n  deviceClass?: string;\n}\n\nexport interface CephNodeSettings {\n  name: string;\n  config?: CephOsdConfiguration;\n  useAllDevices?: boolean;\n  deviceFilter?: RegExp;\n  devicePathFilter?: RegExp;\n  devices?: Array<{ config?: { deviceClass: string }; name: string }>;\n}\n\nexport interface CephDisruptionManagement {\n  managePodBudgets?: boolean;\n  osdMaintenanceTimeout?: number;\n  manageMachineDisruptionBudgets?: boolean;\n  machineDisruptionBudgetNamespace?: string;\n}\n\nexport interface CephStorageSettings {\n  useAllNodes?: boolean;\n  nodes: CephNodeSettings[];\n}\n\nconst CephPlacementConfigurationKeys = [\n  'mgr',\n  'mon',\n  'rbdmirror',\n  'cleanup',\n  'all',\n  'osd',\n] as const;\n\nexport interface CephPlacementNodeAffinity {\n  requiredDuringSchedulingIgnoredDuringExecution: {\n    nodeSelectorTerms: Array<{\n      matchExpressions: Array<{\n        key: string;\n        operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';\n        values?: string[];\n      }>;\n    }>;\n  };\n}\n\nexport interface CephPlacementConfiguration {\n  nodeAffinity?: CephPlacementNodeAffinity;\n  podAffinity?: Affinity;\n  podAntiAffinity?: Affinity;\n  tolerations?: any[];\n  topologySpreadConstraints?: any[];\n}\n\nexport interface CephClusterSpec {\n  priorityClassNames?: StringMap;\n  external?: {\n    enable: boolean;\n  };\n  cephVersion: {\n    image: string;\n    allowUnsupported?: boolean;\n  };\n  dataDirHostPath: string;\n  skipUpgradeChecks?: boolean;\n  continueUpgradeAfterChecksEvenIfNotHealthy?: boolean;\n  dashboard?: CephDashBoardSpec;\n  mon: CephMonSettings;\n  mgr?: CephMgrSettings;\n  storage?: CephStorageSettings;\n  removeOSDsIfOutAndSafeToRemove?: boolean;\n  crashCollector?: {\n    disable: boolean;\n  };\n  network?: CephClusterNetwork;\n  disruptionManagement?: CephDisruptionManagement;\n  placement?: Partial<\n    Record<\n      Partial<typeof CephPlacementConfigurationKeys>[number],\n      CephPlacementConfiguration\n    >\n  >;\n  resources?: Partial<\n    Record<\n      Partial<typeof CephResourceConfigurationKeys>[number],\n      {\n        requests: {\n          cpu: string;\n          memory: string;\n        };\n      }\n    >\n  >;\n  monitoring?: {\n    enabled: boolean;\n    ruleNamespace?: string;\n  };\n}\n\n// https://rook.io/docs/rook/v1.3/ceph-cluster-crd.html\nexport interface CephCluster extends KubernetesResource {\n  spec: CephClusterSpec;\n  status?: CephClusterStatus;\n}\n\nexport interface CephObjectPoolSpec {\n  deviceClass?: string;\n  failureDomain?: string;\n  replicated: {\n    size: number;\n    requireSafeReplicaSize?: boolean;\n  };\n  parameters?: {\n    compression_mode?: string;\n  };\n}\n\nexport interface CephMetadataServer {\n  activeCount: number;\n  activeStandby?: boolean;\n  placement?: CephPlacementConfiguration;\n  resources: ResourceRequirements;\n}\n\nexport interface CephFileSystem extends KubernetesResource {\n  spec: {\n    metadataPool?: any;\n    dataPools?: CephObjectPoolSpec[];\n    preservePoolsOnDelete?: boolean;\n    metadataServer?: CephMetadataServer;\n  };\n  status?: {\n    phase: string;\n  };\n}\n\nexport interface CephBlockPool extends KubernetesResource {\n  spec: {\n    deviceClass?: string;\n    failureDomain: string;\n    replicated: {\n      size: number;\n    };\n  };\n  status?: any;\n}\n\nexport interface CephObjectStore extends KubernetesResource {\n  spec: CephObjectStoreSpec;\n}\n\nexport interface CephObjectStoreGateway {\n  type: string;\n  port: number;\n  instances: number;\n  placement: {\n    nodeAffinity: CephPlacementNodeAffinity;\n  };\n  annotations: unknown;\n  resources: {\n    limits: StringMap;\n  };\n}\n\nexport interface CephObjectStoreSpec {\n  metadataPool?: CephObjectPoolSpec;\n  dataPool?: CephObjectPoolSpec;\n  preservePoolsOnDelete?: boolean;\n  gateway?: CephObjectStoreGateway;\n}\n\n// TopolvmCluster\nexport interface TopolvmNodeStorageStateClass {\n  className: string;\n  vgName: string;\n  deviceStates?: Array<{\n    name: string;\n    message?: string;\n    state: 'Online' | 'Offline';\n  }>;\n  state: 'Ready' | 'UnReady';\n}\n\nexport interface TopolvmClusterStatus {\n  phase?: 'Ready' | 'Failure';\n  nodeStorageState?: Array<{\n    failClasses: TopolvmNodeStorageStateClass[];\n    successClasses: TopolvmNodeStorageStateClass[];\n    node: string;\n    phase: 'Ready' | 'Failure' | 'Unknown' | 'Pending' | '';\n  }>;\n}\n\nexport type TopolvmDeviceType = 'disk' | 'loop' | 'lvm';\n\nexport enum TopolvmClusterStorageDeviceClassStatusEnum {\n  AVAILABLE = 'available',\n  NOT_AVAILABLE = 'not_available',\n}\n\nexport interface TopolvmClusterSpecDeviceClassItem {\n  className: string;\n  default: boolean;\n  volumeGroup: string;\n  devices: Array<{\n    name: string;\n    type: TopolvmDeviceType;\n  }>;\n}\n\nexport interface TopolvmClusterSpecDeviceClass {\n  nodeName: string;\n  classes: TopolvmClusterSpecDeviceClassItem[];\n}\n\nexport interface TopolvmClusterV2Spec {\n  cleanup?: boolean;\n  topolvmVersion: string;\n  storage?: {\n    deviceClasses: TopolvmClusterSpecDeviceClass[];\n  };\n}\n\nexport interface TopolvmClusterV2 extends KubernetesResource {\n  spec: TopolvmClusterV2Spec;\n  status?: TopolvmClusterStatus;\n}\n\n// MinioCluster\n\nexport enum HealthStatus {\n  GREEN = 'green',\n  YELLOW = 'yellow',\n  RED = 'red',\n}\n\nexport enum PoolState {\n  POOL_NOT_CREATED = 'PoolNotCreated',\n  POOL_CREATED = 'PoolCreated',\n  POOL_INITIALIZED = 'PoolInitialized',\n}\n\nexport interface MinioClusterStatus {\n  currentState: string;\n  healthStatus: HealthStatus;\n  drivesOnline: number;\n  pools: Array<{ ssName: string; state: PoolState }>;\n  usage: {\n    // 总minio可用容量\n    capacity: number;\n    // minio已使用容量\n    usage: number;\n    // 总裸设备容量\n    rawCapacity: number;\n    // 已使用裸设备容量\n    rawUsage: number;\n  };\n}\n\nexport interface MinioClusterPool {\n  affinity: {\n    podAntiAffinity?: Affinity;\n    nodeAffinity?: Affinity;\n  };\n  // 存储池名字由pool+序号组成 pool-0 pool-1\n  name: string;\n  // 根据所选节点数， 当节点数为3时， 此处填6， 当节点数>=4时， 填写实际所选节点数\n  servers: number;\n  // 1\n  volumesPerServer: number;\n  volumeClaimTemplate: VolumeClaimTemplate;\n  // 存储池pod容忍，默认容忍一切\n  tolerations?: Array<{ effect: string; operator: string }>;\n  resources?: {\n    limits?: {\n      cpu: string;\n      memory: string;\n    };\n    requests?: {\n      cpu: string;\n      memory: string;\n    };\n  };\n}\n\nexport interface MinioClusterSpec {\n  configuration: {\n    // minio配置secret 由tenant名字+ \"-env-configuration\"\n    name: string;\n  };\n  credsSecret: {\n    name: string;\n  };\n  image?: string;\n  requestAutoCert: boolean;\n  pools: MinioClusterPool[];\n  externalCertSecret?: Array<{ name: string; type: string }>;\n  sideCars?: {\n    resources: {\n      limits?: {\n        cpu: string;\n        memory: string;\n      };\n      requests?: {\n        cpu: string;\n        memory: string;\n      };\n    };\n  };\n}\n\nexport interface MinioCluster extends KubernetesResource {\n  spec: MinioClusterSpec;\n  status?: MinioClusterStatus;\n}\n"]}

package/lib/types/k8s.d.ts

@@ -1,4 +1,4 @@
-import { AccessMode, KubernetesResource, StringMap } from '@alauda-fe/common';
+import { AccessMode, Condition, KubernetesResource, StringMap, Affinity, ResourceRequirements } from '@alauda-fe/common';
 import { ReclaimPolicy, StorageProvisioner, VolumeBindingMode } from './commons';
 export interface VolumeSnapshotClass extends KubernetesResource {
     driver: string;
@@ -103,3 +103,350 @@ export interface PersistentVolumeSpecMeta {
         };
     };
 }
+export interface VolumeClaimTemplate extends KubernetesResource {
+    spec: {
+        accessModes: string[];
+        resources: {
+            requests: {
+                storage: string;
+            };
+        };
+        storageClassName: string;
+    };
+}
+export interface CephClusterNetwork {
+    ipFamily?: string;
+    provider?: string;
+}
+export interface CephClusterStatus {
+    ceph: {
+        health: string;
+        lastChecked: string;
+        details: unknown;
+        capacity?: {
+            bytesAvailable: number;
+            bytesTotal: number;
+            bytesUsed: number;
+            lastUpdated: string;
+        };
+    };
+    conditions: Condition[];
+    message: string;
+    phase: string;
+    state: string;
+    version: {
+        image: string;
+        version: string;
+    };
+    storage: {
+        deviceClasses: Array<{
+            name: string;
+        }>;
+    };
+    network: CephClusterNetwork;
+}
+declare const CephResourceConfigurationKeys: readonly ["mgr", "mon", "osd", "rbdmirror", "prepareosd", "crashcollector", "cleanup"];
+export interface CephDashBoardSpec {
+    enabled: boolean;
+    urlPrefix?: string;
+    port?: number;
+    ssl?: boolean;
+}
+export interface StretchCluster {
+    failureDomainLabel: string;
+    subFailureDomain: string;
+    zones: Array<{
+        name: string;
+        arbiter?: boolean;
+    }>;
+}
+export interface CephMonSettings {
+    count: number;
+    allowMultiplePerNode?: boolean;
+    volumeClaimTemplate?: PersistentVolumeSpec;
+    stretchCluster?: StretchCluster;
+}
+export interface CephMgrSettings {
+    modules: Array<{
+        name: string;
+        enabled: boolean;
+    }>;
+    count?: number;
+}
+export interface CephOsdConfiguration {
+    metadataDevice?: string;
+    storeType?: string;
+    databaseSizeMB?: number;
+    walSizeMB?: number;
+    osdsPerDevice?: number;
+    encryptedDevice?: boolean;
+    deviceClass?: string;
+}
+export interface CephNodeSettings {
+    name: string;
+    config?: CephOsdConfiguration;
+    useAllDevices?: boolean;
+    deviceFilter?: RegExp;
+    devicePathFilter?: RegExp;
+    devices?: Array<{
+        config?: {
+            deviceClass: string;
+        };
+        name: string;
+    }>;
+}
+export interface CephDisruptionManagement {
+    managePodBudgets?: boolean;
+    osdMaintenanceTimeout?: number;
+    manageMachineDisruptionBudgets?: boolean;
+    machineDisruptionBudgetNamespace?: string;
+}
+export interface CephStorageSettings {
+    useAllNodes?: boolean;
+    nodes: CephNodeSettings[];
+}
+declare const CephPlacementConfigurationKeys: readonly ["mgr", "mon", "rbdmirror", "cleanup", "all", "osd"];
+export interface CephPlacementNodeAffinity {
+    requiredDuringSchedulingIgnoredDuringExecution: {
+        nodeSelectorTerms: Array<{
+            matchExpressions: Array<{
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+                values?: string[];
+            }>;
+        }>;
+    };
+}
+export interface CephPlacementConfiguration {
+    nodeAffinity?: CephPlacementNodeAffinity;
+    podAffinity?: Affinity;
+    podAntiAffinity?: Affinity;
+    tolerations?: any[];
+    topologySpreadConstraints?: any[];
+}
+export interface CephClusterSpec {
+    priorityClassNames?: StringMap;
+    external?: {
+        enable: boolean;
+    };
+    cephVersion: {
+        image: string;
+        allowUnsupported?: boolean;
+    };
+    dataDirHostPath: string;
+    skipUpgradeChecks?: boolean;
+    continueUpgradeAfterChecksEvenIfNotHealthy?: boolean;
+    dashboard?: CephDashBoardSpec;
+    mon: CephMonSettings;
+    mgr?: CephMgrSettings;
+    storage?: CephStorageSettings;
+    removeOSDsIfOutAndSafeToRemove?: boolean;
+    crashCollector?: {
+        disable: boolean;
+    };
+    network?: CephClusterNetwork;
+    disruptionManagement?: CephDisruptionManagement;
+    placement?: Partial<Record<Partial<typeof CephPlacementConfigurationKeys>[number], CephPlacementConfiguration>>;
+    resources?: Partial<Record<Partial<typeof CephResourceConfigurationKeys>[number], {
+        requests: {
+            cpu: string;
+            memory: string;
+        };
+    }>>;
+    monitoring?: {
+        enabled: boolean;
+        ruleNamespace?: string;
+    };
+}
+export interface CephCluster extends KubernetesResource {
+    spec: CephClusterSpec;
+    status?: CephClusterStatus;
+}
+export interface CephObjectPoolSpec {
+    deviceClass?: string;
+    failureDomain?: string;
+    replicated: {
+        size: number;
+        requireSafeReplicaSize?: boolean;
+    };
+    parameters?: {
+        compression_mode?: string;
+    };
+}
+export interface CephMetadataServer {
+    activeCount: number;
+    activeStandby?: boolean;
+    placement?: CephPlacementConfiguration;
+    resources: ResourceRequirements;
+}
+export interface CephFileSystem extends KubernetesResource {
+    spec: {
+        metadataPool?: any;
+        dataPools?: CephObjectPoolSpec[];
+        preservePoolsOnDelete?: boolean;
+        metadataServer?: CephMetadataServer;
+    };
+    status?: {
+        phase: string;
+    };
+}
+export interface CephBlockPool extends KubernetesResource {
+    spec: {
+        deviceClass?: string;
+        failureDomain: string;
+        replicated: {
+            size: number;
+        };
+    };
+    status?: any;
+}
+export interface CephObjectStore extends KubernetesResource {
+    spec: CephObjectStoreSpec;
+}
+export interface CephObjectStoreGateway {
+    type: string;
+    port: number;
+    instances: number;
+    placement: {
+        nodeAffinity: CephPlacementNodeAffinity;
+    };
+    annotations: unknown;
+    resources: {
+        limits: StringMap;
+    };
+}
+export interface CephObjectStoreSpec {
+    metadataPool?: CephObjectPoolSpec;
+    dataPool?: CephObjectPoolSpec;
+    preservePoolsOnDelete?: boolean;
+    gateway?: CephObjectStoreGateway;
+}
+export interface TopolvmNodeStorageStateClass {
+    className: string;
+    vgName: string;
+    deviceStates?: Array<{
+        name: string;
+        message?: string;
+        state: 'Online' | 'Offline';
+    }>;
+    state: 'Ready' | 'UnReady';
+}
+export interface TopolvmClusterStatus {
+    phase?: 'Ready' | 'Failure';
+    nodeStorageState?: Array<{
+        failClasses: TopolvmNodeStorageStateClass[];
+        successClasses: TopolvmNodeStorageStateClass[];
+        node: string;
+        phase: 'Ready' | 'Failure' | 'Unknown' | 'Pending' | '';
+    }>;
+}
+export type TopolvmDeviceType = 'disk' | 'loop' | 'lvm';
+export declare enum TopolvmClusterStorageDeviceClassStatusEnum {
+    AVAILABLE = "available",
+    NOT_AVAILABLE = "not_available"
+}
+export interface TopolvmClusterSpecDeviceClassItem {
+    className: string;
+    default: boolean;
+    volumeGroup: string;
+    devices: Array<{
+        name: string;
+        type: TopolvmDeviceType;
+    }>;
+}
+export interface TopolvmClusterSpecDeviceClass {
+    nodeName: string;
+    classes: TopolvmClusterSpecDeviceClassItem[];
+}
+export interface TopolvmClusterV2Spec {
+    cleanup?: boolean;
+    topolvmVersion: string;
+    storage?: {
+        deviceClasses: TopolvmClusterSpecDeviceClass[];
+    };
+}
+export interface TopolvmClusterV2 extends KubernetesResource {
+    spec: TopolvmClusterV2Spec;
+    status?: TopolvmClusterStatus;
+}
+export declare enum HealthStatus {
+    GREEN = "green",
+    YELLOW = "yellow",
+    RED = "red"
+}
+export declare enum PoolState {
+    POOL_NOT_CREATED = "PoolNotCreated",
+    POOL_CREATED = "PoolCreated",
+    POOL_INITIALIZED = "PoolInitialized"
+}
+export interface MinioClusterStatus {
+    currentState: string;
+    healthStatus: HealthStatus;
+    drivesOnline: number;
+    pools: Array<{
+        ssName: string;
+        state: PoolState;
+    }>;
+    usage: {
+        capacity: number;
+        usage: number;
+        rawCapacity: number;
+        rawUsage: number;
+    };
+}
+export interface MinioClusterPool {
+    affinity: {
+        podAntiAffinity?: Affinity;
+        nodeAffinity?: Affinity;
+    };
+    name: string;
+    servers: number;
+    volumesPerServer: number;
+    volumeClaimTemplate: VolumeClaimTemplate;
+    tolerations?: Array<{
+        effect: string;
+        operator: string;
+    }>;
+    resources?: {
+        limits?: {
+            cpu: string;
+            memory: string;
+        };
+        requests?: {
+            cpu: string;
+            memory: string;
+        };
+    };
+}
+export interface MinioClusterSpec {
+    configuration: {
+        name: string;
+    };
+    credsSecret: {
+        name: string;
+    };
+    image?: string;
+    requestAutoCert: boolean;
+    pools: MinioClusterPool[];
+    externalCertSecret?: Array<{
+        name: string;
+        type: string;
+    }>;
+    sideCars?: {
+        resources: {
+            limits?: {
+                cpu: string;
+                memory: string;
+            };
+            requests?: {
+                cpu: string;
+                memory: string;
+            };
+        };
+    };
+}
+export interface MinioCluster extends KubernetesResource {
+    spec: MinioClusterSpec;
+    status?: MinioClusterStatus;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alauda-fe/storage",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "peerDependencies": {
     "@alauda/ui": "^8.0.0",
     "@alauda-fe/i18n": "1.0.11",