@daocloud-proto/mcamel-kafka 0.2.0-68 → 0.2.0-680

package/kafka.pb.ts

@@ -6,6 +6,7 @@
 
 import * as CommonCommon from "./common.pb"
 import * as fm from "./fetch.pb"
+import * as TemplateTemplate from "./template.pb"
 
 type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
 type OneOf<T> =
@@ -20,6 +21,7 @@ export enum Status {
   Failed = "Failed",
   Running = "Running",
   Creating = "Creating",
+  Unknown = "Unknown",
 }
 
 export enum GetKafkaListReqSortDir {
@@ -27,10 +29,28 @@ export enum GetKafkaListReqSortDir {
   DESC = "DESC",
 }
 
-export enum CreateKafkaReqServiceType {
+export enum GetKafkaConfReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetKafkaConfRespItemsParamType {
+  kafka_conf = "kafka_conf",
+  zookeeper_conf = "zookeeper_conf",
+}
+
+export enum ListenerType {
   ClusterIP = "ClusterIP",
+  Internal = "Internal",
   NodePort = "NodePort",
   LoadBalancer = "LoadBalancer",
+  Ingress = "Ingress",
+}
+
+export enum ListenerConfigurationBootstrapService {
+  None = "None",
+  Enable = "Enable",
+  Disable = "Disable",
 }
 
 export enum GetKafkaParamRespSelectSelectType {
@@ -56,9 +76,13 @@ export enum GetKafkaNodeListRespNodeType {
   Kafka = "Kafka",
   Zookeeper = "Zookeeper",
   Manager = "Manager",
+  Exporter = "Exporter",
+  Controller = "Controller",
+  Broker = "Broker",
 }
 
 export type GetKafkaUsersReq = {
+  workspaceId?: number
   cluster?: string
   namespace?: string
   name?: string
@@ -74,6 +98,7 @@ export type GetKafkaUsersResp = {
 }
 
 export type AddKafkaToManagerReq = {
+  workspaceId?: number
   cluster?: string
   namespace?: string
   name?: string
@@ -96,6 +121,45 @@ export type GetKafkaParamReq = {
   cluster?: string
 }
 
+export type GetKafkaConfReq = {
+  workspaceId?: number
+  page?: number
+  pageSize?: number
+  sortDir?: GetKafkaConfReqSortDir
+  sortBy?: string
+  searchKey?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetKafkaConfRespItems = {
+  paramType?: GetKafkaConfRespItemsParamType
+  paramName?: string
+  value?: string
+}
+
+export type GetKafkaConfResp = {
+  items?: GetKafkaConfRespItems[]
+  pagination?: CommonCommon.Pagination
+  conf?: UpdateKafkaConfReq
+}
+
+export type UpdateKafkaConfResp = {
+  message?: string
+}
+
+export type UpdateKafkaConfReq = {
+  workspaceId?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  kafkaConf?: string
+  zookeeperConf?: string
+  confItems?: TemplateTemplate.TemplateConfigItem[]
+  reloadFromConfTemplateName?: string
+}
+
 export type CreateKafkaReqPorts = {
   name?: string
   protocol?: string
@@ -105,6 +169,7 @@ export type CreateKafkaReqPorts = {
 }
 
 export type CreateKafkaReq = {
+  workspaceId?: number
   cluster?: string
   namespace?: string
   name?: string
@@ -113,12 +178,13 @@ export type CreateKafkaReq = {
   kafkaReplicas?: number
   storageClassName?: string
   storageCapacity?: string
-  serviceType?: CreateKafkaReqServiceType
+  serviceType?: CommonCommon.ServiceType
   serviceAnnotations?: {[key: string]: string}
   ports?: CreateKafkaReqPorts[]
   cpuRequest?: string
   cpuLimit?: string
   kafkaConf?: string
+  confTemplateName?: string
   memoryRequest?: string
   memoryLimit?: string
   isOpenManager?: boolean
@@ -129,7 +195,7 @@ export type CreateKafkaReq = {
   managerUser?: string
   managerPass?: string
   managerReplicas?: number
-  managerServiceType?: CreateKafkaReqServiceType
+  managerServiceType?: CommonCommon.ServiceType
   managerPorts?: CreateKafkaReqPorts[]
   managerServiceAnnotations?: {[key: string]: string}
   zookeeperReplicas?: number
@@ -138,9 +204,63 @@ export type CreateKafkaReq = {
   zookeeperCpuLimit?: string
   zookeeperMemoryRequest?: string
   zookeeperMemoryLimit?: string
+  zookeeperStorageClassName?: string
+  zookeeperStorageCapacity?: string
+  affinity?: CommonCommon.Affinity
+  serviceMonitorInterval?: string
+  zookeeperAffinity?: CommonCommon.Affinity
+  isCreateKafkaSuperUser?: boolean
+  externalTrafficPolicy?: CommonCommon.ExternalTrafficPolicy
+  lbTyp?: CommonCommon.LBTyp
+  lbPoolName?: string
+  lbAddress?: string
+  managerExternalTrafficPolicy?: CommonCommon.ExternalTrafficPolicy
+  managerLbTyp?: CommonCommon.LBTyp
+  managerLbPoolName?: string
+  managerLbAddress?: string
+  accessWhitelist?: CommonCommon.AccessWhitelist
+  listeners?: Listener[]
+  controller?: NodePool
+  broker?: NodePool
+}
+
+export type NodePoolVolume = {
+  id?: number
+  class?: string
+  size?: string
+}
+
+export type NodePool = {
+  replicas?: number
+  cpuRequest?: string
+  cpuLimit?: string
+  memoryRequest?: string
+  memoryLimit?: string
+  volumes?: NodePoolVolume[]
   affinity?: CommonCommon.Affinity
 }
 
+export type ListenerConfigurationBroker = {
+  advertisedHost?: string
+  advertisedPort?: number
+  annotations?: {[key: string]: string}
+  broker?: number
+  nodeport?: number
+}
+
+export type ListenerConfiguration = {
+  brokers?: ListenerConfigurationBroker[]
+  bootstrapService?: ListenerConfigurationBootstrapService
+}
+
+export type Listener = {
+  configuration?: ListenerConfiguration
+  type?: ListenerType
+  tls?: boolean
+  port?: number
+  name?: string
+}
+
 export type UpdateKafkaParamsResp = {
   message?: string
 }
@@ -149,13 +269,6 @@ export type GetKafkaParamRespSelectDataStringValue = {
   value?: string
 }
 
-export type GetKafkaParamRespSelectDataResourceValue = {
-  cpuRequest?: string
-  cpuLimit?: string
-  memoryRequest?: string
-  memoryLimit?: string
-}
-
 export type GetKafkaParamRespSelectDataIntValue = {
   value?: number
 }
@@ -170,7 +283,7 @@ type BaseGetKafkaParamRespSelectData = {
 }
 
 export type GetKafkaParamRespSelectData = BaseGetKafkaParamRespSelectData
-  & OneOf<{ sValue: GetKafkaParamRespSelectDataStringValue; rValue: GetKafkaParamRespSelectDataResourceValue; iValue: GetKafkaParamRespSelectDataIntValue; scValue: GetKafkaParamRespSelectDataStorageClassValue }>
+  & OneOf<{ sValue: GetKafkaParamRespSelectDataStringValue; iValue: GetKafkaParamRespSelectDataIntValue; scValue: GetKafkaParamRespSelectDataStorageClassValue }>
 
 export type GetKafkaParamRespSelect = {
   selectType?: GetKafkaParamRespSelectSelectType
@@ -180,7 +293,6 @@ export type GetKafkaParamRespSelect = {
 export type GetKafkaParamResp = {
   version?: GetKafkaParamRespSelect
   replicas?: GetKafkaParamRespSelect
-  resource?: GetKafkaParamRespSelect
   storage?: GetKafkaParamRespSelect
   kafkaConf?: GetKafkaParamRespSelect
   zookeeperConf?: GetKafkaParamRespSelect
@@ -205,6 +317,7 @@ export type GetKafkaOperatorVersionListResp = {
 }
 
 export type DeleteKafkaReq = {
+  workspaceId?: number
   cluster?: string
   namespace?: string
   name?: string
@@ -223,6 +336,7 @@ export type DeleteKafkasResp = {
 }
 
 export type GetKafkaNodeListReq = {
+  workspaceId?: number
   cluster?: string
   namespace?: string
   name?: string
@@ -253,9 +367,12 @@ export type GetKafkaNodeListResp = {
 }
 
 export type GetKafkaGrafanaAddrReq = {
+  workspaceId?: number
   cluster?: string
   namespace?: string
   name?: string
+  from?: string
+  to?: string
 }
 
 export type GetKafkaGrafanaAddrResp = {
@@ -263,6 +380,7 @@ export type GetKafkaGrafanaAddrResp = {
 }
 
 export type GetKafkaReq = {
+  workspaceId?: number
   cluster?: string
   namespace?: string
   name?: string
@@ -285,6 +403,8 @@ export type KafkaClusterItemStatus = {
   kafkaPodsAreReadyNum?: number
   zookeeperPodsAreReadyNum?: number
   common?: CommonCommon.CommonItemStatus
+  brokerPodsAreReadyNum?: number
+  controllerPodsAreReadyNum?: number
 }
 
 export type KafkaClusterItemMetadata = {
@@ -302,41 +422,47 @@ export type KafkaClusterItem = {
   status?: KafkaClusterItemStatus
 }
 
-export class Kafka {
+export class KafkaV1alpha2 {
   static GetKafkaList(req: GetKafkaListReq, initReq?: fm.InitReq): Promise<GetKafkaListResp> {
-    return fm.fetchReq<GetKafkaListReq, GetKafkaListResp>(`/apis/mcamel.io/kafka/v1alpha1/${req["workspaceId"]}/kafkas?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetKafkaListReq, GetKafkaListResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/kafkas?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
   }
   static GetKafkaOperatorVersionList(req: GetKafkaOperatorVersionListReq, initReq?: fm.InitReq): Promise<GetKafkaOperatorVersionListResp> {
-    return fm.fetchReq<GetKafkaOperatorVersionListReq, GetKafkaOperatorVersionListResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka-operator/versions?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetKafkaOperatorVersionListReq, GetKafkaOperatorVersionListResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka-operator/versions?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
   static GetKafka(req: GetKafkaReq, initReq?: fm.InitReq): Promise<GetKafkaResp> {
-    return fm.fetchReq<GetKafkaReq, GetKafkaResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetKafkaReq, GetKafkaResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["workspaceId", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
   static GetKafkaParam(req: GetKafkaParamReq, initReq?: fm.InitReq): Promise<GetKafkaParamResp> {
-    return fm.fetchReq<GetKafkaParamReq, GetKafkaParamResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka-params/${req["cluster"]}?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetKafkaParamReq, GetKafkaParamResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka-params/${req["cluster"]}?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetKafkaConf(req: GetKafkaConfReq, initReq?: fm.InitReq): Promise<GetKafkaConfResp> {
+    return fm.fetchReq<GetKafkaConfReq, GetKafkaConfResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/confs?${fm.renderURLSearchParams(req, ["workspaceId", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static UpdateKafkaConf(req: UpdateKafkaConfReq, initReq?: fm.InitReq): Promise<UpdateKafkaConfResp> {
+    return fm.fetchReq<UpdateKafkaConfReq, UpdateKafkaConfResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/conf`, {...initReq, method: "PUT", body: JSON.stringify(req)})
   }
   static GetKafkaNodeList(req: GetKafkaNodeListReq, initReq?: fm.InitReq): Promise<GetKafkaNodeListResp> {
-    return fm.fetchReq<GetKafkaNodeListReq, GetKafkaNodeListResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka/${req["cluster"]}/${req["namespace"]}/${req["name"]}/nodes?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetKafkaNodeListReq, GetKafkaNodeListResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/nodes?${fm.renderURLSearchParams(req, ["workspaceId", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
   static GetKafkaGrafanaAddr(req: GetKafkaGrafanaAddrReq, initReq?: fm.InitReq): Promise<GetKafkaGrafanaAddrResp> {
-    return fm.fetchReq<GetKafkaGrafanaAddrReq, GetKafkaGrafanaAddrResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka/${req["cluster"]}/${req["namespace"]}/${req["name"]}/grafana?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetKafkaGrafanaAddrReq, GetKafkaGrafanaAddrResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/grafana?${fm.renderURLSearchParams(req, ["workspaceId", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
   static CreateKafka(req: CreateKafkaReq, initReq?: fm.InitReq): Promise<CreateKafkaResp> {
-    return fm.fetchReq<CreateKafkaReq, CreateKafkaResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka`, {...initReq, method: "POST", body: JSON.stringify(req)})
+    return fm.fetchReq<CreateKafkaReq, CreateKafkaResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/kafka`, {...initReq, method: "POST", body: JSON.stringify(req)})
   }
   static UpdateKafkaParams(req: CreateKafkaReq, initReq?: fm.InitReq): Promise<UpdateKafkaParamsResp> {
-    return fm.fetchReq<CreateKafkaReq, UpdateKafkaParamsResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka/${req["cluster"]}/${req["namespace"]}/${req["name"]}/params`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+    return fm.fetchReq<CreateKafkaReq, UpdateKafkaParamsResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/params`, {...initReq, method: "PUT", body: JSON.stringify(req)})
   }
   static DeleteKafka(req: DeleteKafkaReq, initReq?: fm.InitReq): Promise<DeleteKafkaResp> {
-    return fm.fetchReq<DeleteKafkaReq, DeleteKafkaResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka/${req["cluster"]}/${req["namespace"]}/${req["name"]}`, {...initReq, method: "DELETE"})
+    return fm.fetchReq<DeleteKafkaReq, DeleteKafkaResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}`, {...initReq, method: "DELETE"})
   }
   static DeleteKafkas(req: DeleteKafkasReq, initReq?: fm.InitReq): Promise<DeleteKafkasResp> {
-    return fm.fetchReq<DeleteKafkasReq, DeleteKafkasResp>(`/apis/mcamel.io/kafka/v1alpha1/kafkas`, {...initReq, method: "POST", body: JSON.stringify(req)})
+    return fm.fetchReq<DeleteKafkasReq, DeleteKafkasResp>(`/apis/mcamel.io/kafka/v1alpha2/kafkas`, {...initReq, method: "POST", body: JSON.stringify(req)})
   }
   static AddKafkaToManager(req: AddKafkaToManagerReq, initReq?: fm.InitReq): Promise<AddKafkaToManagerResp> {
-    return fm.fetchReq<AddKafkaToManagerReq, AddKafkaToManagerResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka/${req["cluster"]}/${req["namespace"]}/${req["name"]}/manager`, {...initReq, method: "POST", body: JSON.stringify(req)})
+    return fm.fetchReq<AddKafkaToManagerReq, AddKafkaToManagerResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/manager`, {...initReq, method: "POST", body: JSON.stringify(req)})
   }
   static GetKafkaUsers(req: GetKafkaUsersReq, initReq?: fm.InitReq): Promise<GetKafkaUsersResp> {
-    return fm.fetchReq<GetKafkaUsersReq, GetKafkaUsersResp>(`/apis/mcamel.io/kafka/v1alpha1/kafka/${req["cluster"]}/${req["namespace"]}/${req["name"]}/users?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetKafkaUsersReq, GetKafkaUsersResp>(`/apis/mcamel.io/kafka/v1alpha2/kafka/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/users?${fm.renderURLSearchParams(req, ["workspaceId", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
 }

package/metric.pb.ts

@@ -7,10 +7,22 @@
 import * as CommonCommon from "./common.pb"
 import * as fm from "./fetch.pb"
 import * as InsightIoApiInsightV1alpha1Insight from "./insight.pb"
+
+export enum GetAlertsListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
 export type GetAlertsListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetAlertsListReqSortDir
+  sortBy?: string
+  searchKey?: string
   cluster?: string
   namespace?: string
   name?: string
+  workspaceId?: number
 }
 
 export type GetAlertsListResp = {
@@ -20,6 +32,6 @@ export type GetAlertsListResp = {
 
 export class Metric {
   static GetAlertsList(req: GetAlertsListReq, initReq?: fm.InitReq): Promise<GetAlertsListResp> {
-    return fm.fetchReq<GetAlertsListReq, GetAlertsListResp>(`/apis/mcamel.io/kafka/v1alpha1/${req["cluster"]}/${req["namespace"]}/${req["name"]}/alerts?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetAlertsListReq, GetAlertsListResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/${req["cluster"]}/${req["namespace"]}/${req["name"]}/alerts?${fm.renderURLSearchParams(req, ["workspaceId", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name":"@daocloud-proto/mcamel-kafka",
-  "version":"0.2.0-68",
+  "version":"0.2.0-680",
   "description": "",
   "main": "index.js",
   "scripts": {

package/storage_config.pb.ts

@@ -0,0 +1,188 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as CommonCommon from "./common.pb"
+import * as fm from "./fetch.pb"
+
+type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
+type OneOf<T> =
+  | { [k in keyof T]?: undefined }
+  | (
+    keyof T extends infer K ?
+      (K extends string & keyof T ? { [k in K]: T[K] } & Absent<T, K>
+        : never)
+    : never);
+
+export enum GetStorageConfigParamRespSelectSelectType {
+  Single = "Single",
+  Multiple = "Multiple",
+}
+
+export enum GetStorageConfigConsumersRespStorageConfigConsumerType {
+  STORAGE_CONFIG_CONSUMER_TYPE_UNSPECIFIED = "STORAGE_CONFIG_CONSUMER_TYPE_UNSPECIFIED",
+  STORAGE_CONFIG_CONSUMER_TYPE_MYSQL = "STORAGE_CONFIG_CONSUMER_TYPE_MYSQL",
+  STORAGE_CONFIG_CONSUMER_TYPE_REDIS = "STORAGE_CONFIG_CONSUMER_TYPE_REDIS",
+}
+
+export enum GetStorageConfigListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export type GetStorageConfigParamReq = {
+}
+
+export type GetStorageConfigParamRespSelectDataStringValue = {
+  value?: string
+}
+
+export type GetStorageConfigParamRespSelectDataIntValue = {
+  value?: number
+}
+
+
+type BaseGetStorageConfigParamRespSelectData = {
+}
+
+export type GetStorageConfigParamRespSelectData = BaseGetStorageConfigParamRespSelectData
+  & OneOf<{ sValue: GetStorageConfigParamRespSelectDataStringValue; iValue: GetStorageConfigParamRespSelectDataIntValue }>
+
+export type GetStorageConfigParamRespSelect = {
+  selectType?: GetStorageConfigParamRespSelectSelectType
+  data?: GetStorageConfigParamRespSelectData[]
+}
+
+export type GetStorageConfigParamResp = {
+  storageType?: GetStorageConfigParamRespSelect
+}
+
+export type CreateStorageConfigBucketCheckJobReq = {
+  storageType?: string
+  endpoint?: string
+  accessKey?: string
+  secretKey?: string
+  bucket?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type CreateStorageConfigBucketCheckJobResp = {
+  message?: string
+}
+
+export type CreateStorageConfigReq = {
+  workspaceId?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  storageType?: string
+  accessKey?: string
+  secretKey?: string
+  bucket?: string
+  endpoint?: string
+  minioCluster?: string
+  minioNamespace?: string
+  minioName?: string
+  description?: string
+}
+
+export type CreateStorageConfigResp = {
+  message?: string
+}
+
+export type GetStorageConfigConsumersReq = {
+  workspaceId?: number
+  name?: string
+}
+
+export type GetStorageConfigConsumersRespConsumer = {
+  type?: GetStorageConfigConsumersRespStorageConfigConsumerType
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetStorageConfigConsumersResp = {
+  consumers?: GetStorageConfigConsumersRespConsumer[]
+}
+
+export type DeleteStorageConfigReq = {
+  workspaceId?: number
+  name?: string
+  cluster?: string
+  namespace?: string
+}
+
+export type DeleteStorageConfigResp = {
+  message?: string
+}
+
+export type UpdateStorageConfigResp = {
+  message?: string
+}
+
+export type StorageConfigItemStorageConfigStatus = {
+  lastUpdateTimestamp?: string
+  createTimestamp?: string
+}
+
+export type StorageConfigItem = {
+  spec?: CreateStorageConfigReq
+  status?: StorageConfigItemStorageConfigStatus
+}
+
+export type GetStorageConfigReq = {
+  workspaceId?: number
+  name?: string
+  namespace?: string
+  cluster?: string
+}
+
+export type GetStorageConfigResp = {
+  item?: StorageConfigItem
+}
+
+export type GetStorageConfigListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetStorageConfigListReqSortDir
+  sortBy?: string
+  searchKey?: string
+  workspaceId?: number
+}
+
+export type GetStorageConfigListResp = {
+  items?: StorageConfigItem[]
+  pagination?: CommonCommon.Pagination
+}
+
+export class StorageConfig {
+  static GetStorageConfigParam(req: GetStorageConfigParamReq, initReq?: fm.InitReq): Promise<GetStorageConfigParamResp> {
+    return fm.fetchReq<GetStorageConfigParamReq, GetStorageConfigParamResp>(`/apis/mcamel.io/kafka/v1alpha2/storage-config/param?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static CreateStorageConfigBucketCheckJob(req: CreateStorageConfigBucketCheckJobReq, initReq?: fm.InitReq): Promise<CreateStorageConfigBucketCheckJobResp> {
+    return fm.fetchReq<CreateStorageConfigBucketCheckJobReq, CreateStorageConfigBucketCheckJobResp>(`/apis/mcamel.io/kafka/v1alpha2/storage-config/bucket/check-job`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static CreateStorageConfig(req: CreateStorageConfigReq, initReq?: fm.InitReq): Promise<CreateStorageConfigResp> {
+    return fm.fetchReq<CreateStorageConfigReq, CreateStorageConfigResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/storage-config`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static GetStorageConfigConsumers(req: GetStorageConfigConsumersReq, initReq?: fm.InitReq): Promise<GetStorageConfigConsumersResp> {
+    return fm.fetchReq<GetStorageConfigConsumersReq, GetStorageConfigConsumersResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/storage-config/${req["name"]}/consumers?${fm.renderURLSearchParams(req, ["workspaceId", "name"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteStorageConfig(req: DeleteStorageConfigReq, initReq?: fm.InitReq): Promise<DeleteStorageConfigResp> {
+    return fm.fetchReq<DeleteStorageConfigReq, DeleteStorageConfigResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/storage-config/${req["cluster"]}/${req["namespace"]}/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+  static UpdateStorageConfig(req: CreateStorageConfigReq, initReq?: fm.InitReq): Promise<UpdateStorageConfigResp> {
+    return fm.fetchReq<CreateStorageConfigReq, UpdateStorageConfigResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/storage-config/${req["name"]}`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static GetStorageConfig(req: GetStorageConfigReq, initReq?: fm.InitReq): Promise<GetStorageConfigResp> {
+    return fm.fetchReq<GetStorageConfigReq, GetStorageConfigResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/storage-config/${req["name"]}?${fm.renderURLSearchParams(req, ["workspaceId", "name"])}`, {...initReq, method: "GET"})
+  }
+  static GetStorageConfigList(req: GetStorageConfigListReq, initReq?: fm.InitReq): Promise<GetStorageConfigListResp> {
+    return fm.fetchReq<GetStorageConfigListReq, GetStorageConfigListResp>(`/apis/mcamel.io/kafka/v1alpha2/${req["workspaceId"]}/storage-configs?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+}