@daocloud-proto/mcamel-postgresql 0.0.2-6 → 0.0.2-600

package/cluster.pb.ts

@@ -7,12 +7,44 @@
 import * as CommonCommon from "./common.pb"
 import * as fm from "./fetch.pb"
 
+export enum PermissionsType {
+  None = "None",
+  GetInstance = "GetInstance",
+  CreateInstance = "CreateInstance",
+  UpdateInstance = "UpdateInstance",
+  DeleteInstance = "DeleteInstance",
+  GetMetric = "GetMetric",
+  GetInstanceLog = "GetInstanceLog",
+  GetConfig = "GetConfig",
+  UpdateConfig = "UpdateConfig",
+  GetBackup = "GetBackup",
+  CreateBackup = "CreateBackup",
+  UpdateBackup = "UpdateBackup",
+  DeleteBackup = "DeleteBackup",
+  GetBackupConf = "GetBackupConf",
+  CreateBackupConf = "CreateBackupConf",
+  UpdateBackupConf = "UpdateBackupConf",
+  DeleteBackupConf = "DeleteBackupConf",
+  GetTemplate = "GetTemplate",
+  CreateTemplate = "CreateTemplate",
+  UpdateTemplate = "UpdateTemplate",
+  DeleteTemplate = "DeleteTemplate",
+  GetUserPassword = "GetUserPassword",
+  ExportTemplate = "ExportTemplate",
+  ImportTemplate = "ImportTemplate",
+}
+
 export enum EventType {
   EVENT_TYPE_UNSPECIFIED = "EVENT_TYPE_UNSPECIFIED",
   Normal = "Normal",
   Warning = "Warning",
 }
 
+export enum InstallFileReqGVR {
+  None = "None",
+  CustomResourceDefinition = "CustomResourceDefinition",
+}
+
 export enum GetAllEventListReqSortDir {
   ASC = "ASC",
   DESC = "DESC",
@@ -28,11 +60,127 @@ export enum GetWorkspaceListReqSortDir {
   DESC = "DESC",
 }
 
+export enum ClusterItemNetworkMode {
+  Unknown = "Unknown",
+  Flannel = "Flannel",
+  Calico = "Calico",
+}
+
+export enum ClusterSettingPluginPluginName {
+  PLUGIN_NAME_UNSPECIFIED = "PLUGIN_NAME_UNSPECIFIED",
+  HPA = "HPA",
+  Insight = "Insight",
+  GPU = "GPU",
+  METALLB = "METALLB",
+  Spiderpool = "Spiderpool",
+  CustomMetrics = "CustomMetrics",
+  CronHPA = "CronHPA",
+  VPA = "VPA",
+  Hwameistor = "Hwameistor",
+  Flannel = "Flannel",
+  KubeOvn = "KubeOvn",
+  OLM = "OLM",
+  EgressGateway = "EgressGateway",
+}
+
 export enum GetInsightAgentStatusRespInsightAgentStatus {
   NotInstall = "NotInstall",
   Install = "Install",
 }
 
+export type GetClusterReq = {
+  workspaceId?: number
+  name?: string
+}
+
+export type GetClusterResp = {
+  cluster?: ClusterItem
+}
+
+export type InstallFileReq = {
+  cluster?: string
+  path?: string
+  gvr?: InstallFileReqGVR
+}
+
+export type InstallFileResp = {
+  message?: string
+}
+
+export type GetInstallVersionReq = {
+  cluster?: string
+}
+
+export type GetInstallVersionRespSupportVersion = {
+  minVersion?: string
+  maxVersion?: string
+}
+
+export type GetInstallVersionRespStatus = {
+  inRange?: boolean
+}
+
+export type GetInstallVersionResp = {
+  clusterVersion?: string
+  supportVersion?: GetInstallVersionRespSupportVersion
+  status?: GetInstallVersionRespStatus
+}
+
+export type RestartInstanceReq = {
+  workspaceId?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  extra?: string
+}
+
+export type RestartInstanceResp = {
+  message?: string
+}
+
+export type GetPermissionsListReq = {
+  workspaceId?: number
+}
+
+export type GetPermissionsListRespPermissions = {
+  getInstance?: boolean
+  createInstance?: boolean
+  updateInstance?: boolean
+  deleteInstance?: boolean
+  getMetric?: boolean
+  getInstanceLog?: boolean
+  getConfig?: boolean
+  updateConfig?: boolean
+  getBackup?: boolean
+  createBackup?: boolean
+  updateBackup?: boolean
+  deleteBackup?: boolean
+  getBackupConf?: boolean
+  createBackupConf?: boolean
+  updateBackupConf?: boolean
+  deleteBackupConf?: boolean
+  getTemplate?: boolean
+  createTemplate?: boolean
+  updateTemplate?: boolean
+  deleteTemplate?: boolean
+  getUserPassword?: boolean
+  exportTemplate?: boolean
+  importTemplate?: boolean
+}
+
+export type GetPermissionsListResp = {
+  permissionsBool?: GetPermissionsListRespPermissions
+  permissions?: PermissionsType[]
+}
+
+export type GetAllEventKindsListResp = {
+  data?: string[]
+}
+
+export type GetAllEventKindsListReq = {
+  cluster?: string
+}
+
 export type GetAllEventListReq = {
   page?: number
   pageSize?: number
@@ -43,6 +191,7 @@ export type GetAllEventListReq = {
   namespace?: string
   name?: string
   eventType?: EventType
+  kindName?: string
 }
 
 export type GetAllEventListRespItemsSource = {
@@ -97,8 +246,32 @@ export type GetClusterNodeLabelListRespLabel = {
   value?: string[]
 }
 
+export type GetClusterNodeLabelListRespNode2Label = {
+  nodeName?: string
+  label?: GetClusterNodeLabelListRespLabel[]
+}
+
 export type GetClusterNodeLabelListResp = {
   items?: GetClusterNodeLabelListRespLabel[]
+  items1?: GetClusterNodeLabelListRespNode2Label[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetClusterPodLabelListReq = {
+  page?: number
+  pageSize?: number
+  searchKey?: string
+  filterNamespace?: string
+  cluster?: string
+}
+
+export type GetClusterPodLabelListRespLabel = {
+  key?: string
+  value?: string[]
+}
+
+export type GetClusterPodLabelListResp = {
+  items?: GetClusterPodLabelListRespLabel[]
   pagination?: CommonCommon.Pagination
 }
 
@@ -174,6 +347,7 @@ export type GetWorkspaceListReq = {
 export type GetWorkspaceListRespItem = {
   workspaceId?: number
   alias?: string
+  visible?: boolean
 }
 
 export type GetWorkspaceListResp = {
@@ -181,15 +355,55 @@ export type GetWorkspaceListResp = {
   pagination?: CommonCommon.Pagination
 }
 
+export type GetClusterHostnetworkPortsReq = {
+  workspaceId?: number
+  cluster?: string
+}
+
 export type GetClusterListReq = {
   workspaceId?: number
+  searchKey?: string
+}
+
+export type GetClusterHostnetworkPortsResp = {
+  items?: number[]
 }
 
 export type GetClusterListResp = {
   items?: string[]
+  clusters?: ClusterItem[]
   pagination?: CommonCommon.Pagination
 }
 
+export type ClusterItemMetadata = {
+  name?: string
+}
+
+export type ClusterItemStatus = {
+  networkMode?: ClusterItemNetworkMode[]
+  setting?: ClusterSetting
+  clusterStatus?: CommonCommon.ClusterStatus
+}
+
+export type ClusterItem = {
+  metadata?: ClusterItemMetadata
+  status?: ClusterItemStatus
+}
+
+export type ClusterSettingPlugin = {
+  name?: ClusterSettingPluginPluginName
+  enabled?: boolean
+  intelligentDetection?: boolean
+  externalAddress?: string
+  setting?: string
+  healthy?: boolean
+}
+
+export type ClusterSetting = {
+  plugins?: ClusterSettingPlugin[]
+  network?: ClusterSettingPlugin[]
+}
+
 export type GetClusterNamespaceListReq = {
   workspaceId?: number
   cluster?: string
@@ -197,6 +411,7 @@ export type GetClusterNamespaceListReq = {
 
 export type GetClusterNamespaceListResp = {
   items?: string[]
+  disableItems?: string[]
   pagination?: CommonCommon.Pagination
 }
 
@@ -206,12 +421,49 @@ export type GetInsightAgentStatusReq = {
 
 export type GetInsightAgentStatusResp = {
   status?: GetInsightAgentStatusRespInsightAgentStatus
+  clusterStatus?: CommonCommon.ClusterStatus
+}
+
+export type GetResourceQuotaReq = {
+  cluster?: string
+  namespace?: string
+}
+
+export type GetResourceQuotaRespMetadata = {
+  uid?: string
+  name?: string
+  namespace?: string
+  annotations?: {[key: string]: string}
+  resourceVersion?: string
+  creationTimestamp?: string
+}
+
+export type GetResourceQuotaRespSpec = {
+  hard?: {[key: string]: string}
+}
+
+export type GetResourceQuotaRespStatus = {
+  hard?: {[key: string]: string}
+  used?: {[key: string]: string}
+  available?: {[key: string]: string}
+}
+
+export type GetResourceQuotaResp = {
+  metadata?: GetResourceQuotaRespMetadata
+  spec?: GetResourceQuotaRespSpec
+  status?: GetResourceQuotaRespStatus
 }
 
 export class Cluster {
   static GetClusterList(req: GetClusterListReq, initReq?: fm.InitReq): Promise<GetClusterListResp> {
     return fm.fetchReq<GetClusterListReq, GetClusterListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/clusters?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
   }
+  static GetCluster(req: GetClusterReq, initReq?: fm.InitReq): Promise<GetClusterResp> {
+    return fm.fetchReq<GetClusterReq, GetClusterResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/clusters/${req["name"]}?${fm.renderURLSearchParams(req, ["workspaceId", "name"])}`, {...initReq, method: "GET"})
+  }
+  static GetClusterHostnetworkPorts(req: GetClusterHostnetworkPortsReq, initReq?: fm.InitReq): Promise<GetClusterHostnetworkPortsResp> {
+    return fm.fetchReq<GetClusterHostnetworkPortsReq, GetClusterHostnetworkPortsResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/hostnetwork-ports?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
   static GetClusterNamespaceList(req: GetClusterNamespaceListReq, initReq?: fm.InitReq): Promise<GetClusterNamespaceListResp> {
     return fm.fetchReq<GetClusterNamespaceListReq, GetClusterNamespaceListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/${req["cluster"]}/namespaces?${fm.renderURLSearchParams(req, ["workspaceId", "cluster"])}`, {...initReq, method: "GET"})
   }
@@ -221,6 +473,9 @@ export class Cluster {
   static GetClusterNodeLabelList(req: GetClusterNodeLabelListReq, initReq?: fm.InitReq): Promise<GetClusterNodeLabelListResp> {
     return fm.fetchReq<GetClusterNodeLabelListReq, GetClusterNodeLabelListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/nodelabels?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
   }
+  static GetClusterPodLabelList(req: GetClusterPodLabelListReq, initReq?: fm.InitReq): Promise<GetClusterPodLabelListResp> {
+    return fm.fetchReq<GetClusterPodLabelListReq, GetClusterPodLabelListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/podlabels?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
   static GetWorkspaceList(req: GetWorkspaceListReq, initReq?: fm.InitReq): Promise<GetWorkspaceListResp> {
     return fm.fetchReq<GetWorkspaceListReq, GetWorkspaceListResp>(`/apis/mcamel.io/postgresql/v1alpha1/workspaces?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
@@ -233,7 +488,25 @@ export class Cluster {
   static GetAllEventList(req: GetAllEventListReq, initReq?: fm.InitReq): Promise<GetAllEventListResp> {
     return fm.fetchReq<GetAllEventListReq, GetAllEventListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/${req["namespace"]}/${req["name"]}/all-events?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
+  static GetAllEventKindsList(req: GetAllEventKindsListReq, initReq?: fm.InitReq): Promise<GetAllEventKindsListResp> {
+    return fm.fetchReq<GetAllEventKindsListReq, GetAllEventKindsListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/all-events-kinds?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
   static GetMetallbIPAddressPoolsList(req: GetMetallbIPAddressPoolsListReq, initReq?: fm.InitReq): Promise<GetMetallbIPAddressPoolsListResp> {
     return fm.fetchReq<GetMetallbIPAddressPoolsListReq, GetMetallbIPAddressPoolsListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/lbaddress/pools?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
   }
+  static GetPermissionsList(req: GetPermissionsListReq, initReq?: fm.InitReq): Promise<GetPermissionsListResp> {
+    return fm.fetchReq<GetPermissionsListReq, GetPermissionsListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/permissions?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+  static RestartInstance(req: RestartInstanceReq, initReq?: fm.InitReq): Promise<RestartInstanceResp> {
+    return fm.fetchReq<RestartInstanceReq, RestartInstanceResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/restart`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static InstallFile(req: InstallFileReq, initReq?: fm.InitReq): Promise<InstallFileResp> {
+    return fm.fetchReq<InstallFileReq, InstallFileResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/install-file`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static GetInstallVersion(req: GetInstallVersionReq, initReq?: fm.InitReq): Promise<GetInstallVersionResp> {
+    return fm.fetchReq<GetInstallVersionReq, GetInstallVersionResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/install-version?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetResourceQuota(req: GetResourceQuotaReq, initReq?: fm.InitReq): Promise<GetResourceQuotaResp> {
+    return fm.fetchReq<GetResourceQuotaReq, GetResourceQuotaResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["cluster"]}/${req["namespace"]}/resourcequota?${fm.renderURLSearchParams(req, ["cluster", "namespace"])}`, {...initReq, method: "GET"})
+  }
 }

package/common.pb.ts

@@ -20,6 +20,16 @@ export enum ServiceType {
   LoadBalancer = "LoadBalancer",
 }
 
+export enum ClusterStatus {
+  UNSPECIFIED = "UNSPECIFIED",
+  Unknown = "Unknown",
+  Creating = "Creating",
+  Running = "Running",
+  Updating = "Updating",
+  Deleting = "Deleting",
+  Failed = "Failed",
+}
+
 export enum PageInfoReqSortDir {
   ASC = "ASC",
   DESC = "DESC",
@@ -40,6 +50,14 @@ export enum PodCommonConditionStatus {
   PodConditionStatusFalse = "PodConditionStatusFalse",
 }
 
+export enum PodCommonFilterPodStatus {
+  UNSPECIFIED = "UNSPECIFIED",
+  RUNNING = "RUNNING",
+  ERROR = "ERROR",
+  COMPLETED = "COMPLETED",
+  WAITING = "WAITING",
+}
+
 export type Affinity = {
   nodeAffinity?: NodeAffinity
   podAffinity?: PodAffinity
@@ -145,10 +163,16 @@ export type PodCommon = {
   cpuLimit?: number
   memoryUsage?: number
   memoryLimit?: number
+  pvUsedInGb?: number
+  pvAllocatedInGb?: number
   conditions?: PodCommonCondition[]
   containersName?: string[]
   ownerReference?: OwnerReference[]
   initContainersName?: string[]
+  initContainersStatuses?: ContainerStatus[]
+  containersStatuses?: ContainerStatus[]
+  podStatus?: string
+  annotations?: {[key: string]: string}
 }
 
 export type OwnerReference = {
@@ -162,4 +186,53 @@ export type CommonItemStatus = {
   serviceAddresses?: string[]
   webManagerAddress?: string
   webLogAddress?: string
+  avgPvAllocatedInGb?: number
+  avgPvUsedInGb?: number
+  cpuUtilization?: number
+  memoryUtilization?: number
+  clusterStatus?: ClusterStatus
+}
+
+export type AccessWhitelistInternal = {
+  namespace?: string
+  podSelector?: {[key: string]: string}
+}
+
+export type AccessWhitelistExternal = {
+  cidr?: string
+  ip?: string
+}
+
+export type AccessWhitelist = {
+  internals?: AccessWhitelistInternal[]
+  externals?: AccessWhitelistExternal[]
+}
+
+export type ContainerStatus = {
+  name?: string
+  state?: ContainerState
+}
+
+export type ContainerState = {
+  waiting?: ContainerStateWaiting
+  running?: ContainerStateRunning
+  terminated?: ContainerStateTerminated
+}
+
+export type ContainerStateWaiting = {
+  reason?: string
+  message?: string
+}
+
+export type ContainerStateRunning = {
+  startedAt?: string
+}
+
+export type ContainerStateTerminated = {
+  exitCode?: number
+  signal?: number
+  reason?: string
+  message?: string
+  startedAt?: string
+  finishedAt?: string
 }

package/insight.pb.ts

@@ -20,27 +20,23 @@ export enum TargetType {
   DEPLOYMENT = "DEPLOYMENT",
   STATEFULSET = "STATEFULSET",
   DAEMONSET = "DAEMONSET",
-  CRONJOB = "CRONJOB",
   POD = "POD",
 }
 
-export enum AlertStatus {
-  ALERT_STATUS_UNSPECIFIED = "ALERT_STATUS_UNSPECIFIED",
-  ALERT_STATUS_FIRING = "ALERT_STATUS_FIRING",
-  ALERT_STATUS_RESOLVED = "ALERT_STATUS_RESOLVED",
-}
-
 export type AlertSummary = {
-  alertId?: string
+  id?: string
+  groupName?: string
+  groupId?: string
   ruleName?: string
-  severity?: Severity
+  ruleId?: string
   clusterName?: string
   namespace?: string
   targetType?: TargetType
-  targetName?: string
-  status?: AlertStatus
+  target?: string
+  severity?: Severity
+  value?: string
+  notifyResponse?: string
   description?: string
   startAt?: string
   updateAt?: string
-  notifyResponse?: string
 }

package/metric.pb.ts

@@ -7,7 +7,18 @@
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name":"@daocloud-proto/mcamel-postgresql",
-  "version":"0.0.2-6",
+  "version":"0.0.2-600",
   "description": "",
   "main": "index.js",
   "scripts": {

package/postgresql.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,81 @@ export enum Status {
   Failed = "Failed",
   Running = "Running",
   Creating = "Creating",
+  Unknown = "Unknown",
+}
+
+export enum GetPostgresqlTopologyRespNodePodStatus {
+  Pending = "Pending",
+  Running = "Running",
+  Succeeded = "Succeeded",
+  Failed = "Failed",
+  Unknown = "Unknown",
+  Terminating = "Terminating",
+}
+
+export enum GetPostgresqlTopologyRespNodeRole {
+  RoleUnknown = "RoleUnknown",
+  Primary = "Primary",
+  Standby = "Standby",
+}
+
+export enum GetPostgresqlTopologyRespNodeSyncState {
+  SyncStateUnknown = "SyncStateUnknown",
+  Sync = "Sync",
+  Async = "Async",
+  Potential = "Potential",
+  Quorum = "Quorum",
+}
+
+export enum GetPostgresqlTopologyRespNodeState {
+  StateUnknown = "StateUnknown",
+  Startup = "Startup",
+  Catchup = "Catchup",
+  Streaming = "Streaming",
+  Backup = "Backup",
+  Stopping = "Stopping",
+}
+
+export enum GetPostgresqlS3ConfigListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetPostgresqlBackupListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetPostgresqlBackupListRespPostgresqlBackupItemStatusStatus {
+  Running = "Running",
+  Failed = "Failed",
+  Succeeded = "Succeeded",
+}
+
+export enum GetPostgresqlBackupListRespPostgresqlBackupItemStatusBackupType {
+  Full = "Full",
+  Incremental = "Incremental",
+}
+
+export enum GetPostgresqlBackupListRespPostgresqlBackupItemStatusBackupMethod {
+  Manual = "Manual",
+  Auto = "Auto",
+}
+
+export enum PostgresqlBackupItemStatusStatus {
+  Running = "Running",
+  Failed = "Failed",
+  Succeeded = "Succeeded",
+}
+
+export enum PostgresqlBackupItemStatusBackupType {
+  Full = "Full",
+  Incremental = "Incremental",
+}
+
+export enum PostgresqlBackupItemStatusBackupMethod {
+  Manual = "Manual",
+  Auto = "Auto",
 }
 
 export enum GetPostgresqlListReqSortDir {
@@ -52,8 +128,8 @@ export enum GetPostgresqlPodListRespPodStatus {
 }
 
 export enum GetPostgresqlPodListRespPodType {
-  Master = "Master",
-  Replica = "Replica",
+  Primary = "Primary",
+  Standby = "Standby",
   PgAdmin = "PgAdmin",
 }
 
@@ -67,6 +143,210 @@ export enum GetPostgresqlConfRespItemsParamType {
   conf = "conf",
 }
 
+export enum PostgresqlItemStatusRestoreInitialStatus {
+  Unknown = "Unknown",
+  Running = "Running",
+  Failed = "Failed",
+  Succeeded = "Succeeded",
+}
+
+export type GetPostgresqlTopologyReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetPostgresqlTopologyRespNode = {
+  cluster?: string
+  namespace?: string
+  podName?: string
+  ip?: string
+  podStatus?: GetPostgresqlTopologyRespNodePodStatus
+  totalContainer?: number
+  totalContainerReady?: number
+  podCpuRequest?: string
+  podMemoryRequest?: string
+  podCpuLimit?: string
+  podMemoryLimit?: string
+  role?: GetPostgresqlTopologyRespNodeRole
+  syncState?: GetPostgresqlTopologyRespNodeSyncState
+  state?: GetPostgresqlTopologyRespNodeState
+  sentLsn?: string
+  writeLsn?: string
+  flushLsn?: string
+  replayLsn?: string
+}
+
+export type GetPostgresqlTopologyRespEdges = {
+  source?: string
+  target?: string
+  properties?: {[key: string]: string}
+}
+
+export type GetPostgresqlTopologyResp = {
+  nodes?: GetPostgresqlTopologyRespNode[]
+  edges?: GetPostgresqlTopologyRespEdges[]
+}
+
+export type CreatePostgresqlRestoreReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  backupName?: string
+  targetPostgresqlName?: string
+  targetPostgresqlNamespace?: string
+  targetPostgresqlCluster?: string
+}
+
+export type CreatePostgresqlRestoreResp = {
+  message?: string
+}
+
+export type DeletePostgresqlBackupReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  backupName?: string
+  removeRemoteBackup?: boolean
+}
+
+export type DeletePostgresqlBackupResp = {
+  message?: string
+}
+
+export type CreateBucketExistCheckingReq = {
+  endpoint?: string
+  accessKey?: string
+  secretKey?: string
+  bucket?: string
+}
+
+export type CreateBucketExistCheckingResp = {
+  message?: string
+}
+
+export type UpdatePostgresqlS3ConfigReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  description?: string
+  endpoint?: string
+  accessKey?: string
+  secretKey?: string
+  bucket?: string
+  retentionTime?: string
+  provider?: string
+}
+
+export type UpdatePostgresqlS3ConfigResp = {
+  message?: string
+}
+
+export type GetPostgresqlS3ConfigListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetPostgresqlS3ConfigListReqSortDir
+  sortBy?: string
+  searchKey?: string
+  workspaceId?: number
+}
+
+export type GetPostgresqlS3ConfigListRespGetPostgresqlS3ConfigItemsStatus = {
+  createTimestamp?: string
+  updateTimestamp?: string
+  backupPath?: string
+}
+
+export type GetPostgresqlS3ConfigListRespGetPostgresqlS3ConfigItems = {
+  spec?: UpdatePostgresqlS3ConfigReq
+  status?: GetPostgresqlS3ConfigListRespGetPostgresqlS3ConfigItemsStatus
+}
+
+export type GetPostgresqlS3ConfigListResp = {
+  items?: GetPostgresqlS3ConfigListRespGetPostgresqlS3ConfigItems[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type UpdatePostgresqlBackupConfigReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  isOpenAutoBackup?: boolean
+  backupSchedule?: string
+}
+
+export type UpdatePostgresqlBackupConfigResp = {
+  message?: string
+}
+
+export type GetPostgresqlBackupListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetPostgresqlBackupListReqSortDir
+  sortBy?: string
+  searchKey?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetPostgresqlBackupListRespPostgresqlBackupItemMetadata = {
+  creationTimestamp?: string
+  name?: string
+  namespace?: string
+}
+
+export type GetPostgresqlBackupListRespPostgresqlBackupItemStatusJobCondition = {
+  type?: string
+  status?: string
+  reason?: string
+  message?: string
+}
+
+export type GetPostgresqlBackupListRespPostgresqlBackupItemStatus = {
+  completionTimestamp?: string
+  startTime?: string
+  active?: number
+  succeeded?: number
+  failed?: number
+  conditions?: GetPostgresqlBackupListRespPostgresqlBackupItemStatusJobCondition[]
+  status?: GetPostgresqlBackupListRespPostgresqlBackupItemStatusStatus
+  backupType?: GetPostgresqlBackupListRespPostgresqlBackupItemStatusBackupType
+  backupMethod?: GetPostgresqlBackupListRespPostgresqlBackupItemStatusBackupMethod
+  storePath?: string
+}
+
+export type GetPostgresqlBackupListRespPostgresqlBackupItem = {
+  metadata?: GetPostgresqlBackupListRespPostgresqlBackupItemMetadata
+  spec?: CreatePostgresqlBackupReq
+  status?: GetPostgresqlBackupListRespPostgresqlBackupItemStatus
+}
+
+export type GetPostgresqlBackupListResp = {
+  items?: GetPostgresqlBackupListRespPostgresqlBackupItem[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type CreatePostgresqlBackupReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  backupName?: string
+}
+
+export type CreatePostgresqlBackupResp = {
+  message?: string
+}
+
+export type PostgresqlBackupItemStatus = {
+  status?: PostgresqlBackupItemStatusStatus
+  message?: string
+  backupUrl?: string
+  backupType?: PostgresqlBackupItemStatusBackupType
+  backupMethod?: PostgresqlBackupItemStatusBackupMethod
+  completionTimestamp?: string
+}
+
 export type GetPostgresqlUsersReq = {
   cluster?: string
   namespace?: string
@@ -89,6 +369,8 @@ export type GetPostgresqlListReq = {
   sortBy?: string
   searchKey?: string
   workspaceId?: number
+  filterCluster?: string
+  filterNamespace?: string
 }
 
 export type GetPostgresqlConfReq = {
@@ -136,6 +418,7 @@ export type CreatePostgresqlReq = {
   memoryRequest?: string
   memoryLimit?: string
   conf?: string
+  confTemplateName?: string
   isOpenPgAdmin?: boolean
   pgAdminServiceType?: CommonCommon.ServiceType
   pgAdminNodePort?: number
@@ -147,6 +430,8 @@ export type CreatePostgresqlReq = {
   pgAdminDefaultEmail?: string
   pgAdminDefaultPassword?: string
   affinity?: CommonCommon.Affinity
+  backupConfig?: UpdatePostgresqlBackupConfigReq
+  accessWhitelist?: CommonCommon.AccessWhitelist
   externalTrafficPolicy?: CommonCommon.ExternalTrafficPolicy
   lbTyp?: CommonCommon.LBTyp
   lbPoolName?: string
@@ -162,6 +447,8 @@ export type UpdatePostgresqlConfReq = {
   namespace?: string
   name?: string
   conf?: string
+  confItems?: TemplateTemplate.TemplateConfigItem[]
+  reloadFromConfTemplateName?: string
 }
 
 export type UpdatePostgresqlParamsResp = {
@@ -176,13 +463,6 @@ export type GetPostgresqlParamRespSelectDataStringValue = {
   value?: string
 }
 
-export type GetPostgresqlParamRespSelectDataResourceValue = {
-  cpuRequest?: string
-  cpuLimit?: string
-  memoryRequest?: string
-  memoryLimit?: string
-}
-
 export type GetPostgresqlParamRespSelectDataIntValue = {
   value?: number
 }
@@ -197,7 +477,7 @@ type BaseGetPostgresqlParamRespSelectData = {
 }
 
 export type GetPostgresqlParamRespSelectData = BaseGetPostgresqlParamRespSelectData
-  & OneOf<{ sValue: GetPostgresqlParamRespSelectDataStringValue; rValue: GetPostgresqlParamRespSelectDataResourceValue; iValue: GetPostgresqlParamRespSelectDataIntValue; scValue: GetPostgresqlParamRespSelectDataStorageClassValue }>
+  & OneOf<{ sValue: GetPostgresqlParamRespSelectDataStringValue; iValue: GetPostgresqlParamRespSelectDataIntValue; scValue: GetPostgresqlParamRespSelectDataStorageClassValue }>
 
 export type GetPostgresqlParamRespSelect = {
   selectType?: GetPostgresqlParamRespSelectSelectType
@@ -208,7 +488,6 @@ export type GetPostgresqlParamResp = {
   version?: GetPostgresqlParamRespSelect
   conf?: GetPostgresqlParamRespSelect
   replicas?: GetPostgresqlParamRespSelect
-  resource?: GetPostgresqlParamRespSelect
   storage?: GetPostgresqlParamRespSelect
 }
 
@@ -288,6 +567,8 @@ export type GetPostgresqlGrafanaAddrReq = {
   cluster?: string
   namespace?: string
   name?: string
+  from?: string
+  to?: string
 }
 
 export type GetPostgresqlGrafanaAddrResp = {
@@ -327,6 +608,8 @@ export type PostgresqlItemStatus = {
   clusterIPs?: string[]
   avgReplicationLagInBytes?: string
   common?: CommonCommon.CommonItemStatus
+  isControl?: boolean
+  restoreInitialStatus?: PostgresqlItemStatusRestoreInitialStatus
 }
 
 export type PostgresqlItemMetadata = {
@@ -334,6 +617,7 @@ export type PostgresqlItemMetadata = {
   creationTimestamp?: string
   name?: string
   namespace?: string
+  uid?: string
 }
 
 export type PostgresqlItem = {
@@ -384,4 +668,31 @@ export class Postgresql {
   static GetPostgresqlUsers(req: GetPostgresqlUsersReq, initReq?: fm.InitReq): Promise<GetPostgresqlUsersResp> {
     return fm.fetchReq<GetPostgresqlUsersReq, GetPostgresqlUsersResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/${req["cluster"]}/${req["namespace"]}/${req["name"]}/users?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
+  static GetPostgresqlBackupList(req: GetPostgresqlBackupListReq, initReq?: fm.InitReq): Promise<GetPostgresqlBackupListResp> {
+    return fm.fetchReq<GetPostgresqlBackupListReq, GetPostgresqlBackupListResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/${req["cluster"]}/${req["namespace"]}/${req["name"]}/backups?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static CreatePostgresqlBackup(req: CreatePostgresqlBackupReq, initReq?: fm.InitReq): Promise<CreatePostgresqlBackupResp> {
+    return fm.fetchReq<CreatePostgresqlBackupReq, CreatePostgresqlBackupResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/${req["cluster"]}/${req["namespace"]}/${req["name"]}/backup`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static CreatePostgresqlRestore(req: CreatePostgresqlRestoreReq, initReq?: fm.InitReq): Promise<CreatePostgresqlRestoreResp> {
+    return fm.fetchReq<CreatePostgresqlRestoreReq, CreatePostgresqlRestoreResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/${req["cluster"]}/${req["namespace"]}/${req["name"]}/restore`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static DeletePostgresqlBackup(req: DeletePostgresqlBackupReq, initReq?: fm.InitReq): Promise<DeletePostgresqlBackupResp> {
+    return fm.fetchReq<DeletePostgresqlBackupReq, DeletePostgresqlBackupResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/backups/${req["cluster"]}/${req["namespace"]}/${req["name"]}/backup/${req["backupName"]}`, {...initReq, method: "DELETE", body: JSON.stringify(req)})
+  }
+  static UpdatePostgresqlBackupConfig(req: UpdatePostgresqlBackupConfigReq, initReq?: fm.InitReq): Promise<UpdatePostgresqlBackupConfigResp> {
+    return fm.fetchReq<UpdatePostgresqlBackupConfigReq, UpdatePostgresqlBackupConfigResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/${req["cluster"]}/${req["namespace"]}/${req["name"]}/backup/config`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static GetPostgresqlS3ConfigList(req: GetPostgresqlS3ConfigListReq, initReq?: fm.InitReq): Promise<GetPostgresqlS3ConfigListResp> {
+    return fm.fetchReq<GetPostgresqlS3ConfigListReq, GetPostgresqlS3ConfigListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/s3/configs?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+  static UpdatePostgresqlS3Config(req: UpdatePostgresqlS3ConfigReq, initReq?: fm.InitReq): Promise<UpdatePostgresqlS3ConfigResp> {
+    return fm.fetchReq<UpdatePostgresqlS3ConfigReq, UpdatePostgresqlS3ConfigResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/${req["cluster"]}/${req["namespace"]}/${req["name"]}/s3/config`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static CreateBucketExistChecking(req: CreateBucketExistCheckingReq, initReq?: fm.InitReq): Promise<CreateBucketExistCheckingResp> {
+    return fm.fetchReq<CreateBucketExistCheckingReq, CreateBucketExistCheckingResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/s3/config/checking`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static GetPostgresqlTopology(req: GetPostgresqlTopologyReq, initReq?: fm.InitReq): Promise<GetPostgresqlTopologyResp> {
+    return fm.fetchReq<GetPostgresqlTopologyReq, GetPostgresqlTopologyResp>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/${req["cluster"]}/${req["namespace"]}/${req["name"]}/topology?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
 }

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/postgresql/v1alpha1/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/postgresql/v1alpha1/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/postgresql/v1alpha1/${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/postgresql/v1alpha1/${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/postgresql/v1alpha1/${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/postgresql/v1alpha1/${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/postgresql/v1alpha1/${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/postgresql/v1alpha1/${req["workspaceId"]}/storage-configs?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+}

package/template.pb.ts

@@ -0,0 +1,194 @@
+/* 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"
+
+export enum TemplateInstanceType {
+  MysqlMasterReplica = "MysqlMasterReplica",
+  RedisStandalone = "RedisStandalone",
+  RedisFailover = "RedisFailover",
+  RedisCluster = "RedisCluster",
+  KafkaConfig = "KafkaConfig",
+  MysqlMgrConfig = "MysqlMgrConfig",
+  MongodbConfig = "MongodbConfig",
+  PostgresqlConfig = "PostgresqlConfig",
+  RabbitmqConfig = "RabbitmqConfig",
+}
+
+export enum GetTemplateConfigReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetTemplateConfigListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum TemplateConfigItemValueType {
+  String = "String",
+  SingleSelection = "SingleSelection",
+  MultiString = "MultiString",
+}
+
+export type UpdateTemplateConfigToItemReq = {
+  workspaceId?: number
+  conf?: string
+  version?: string
+  templateInstanceType?: TemplateInstanceType
+}
+
+export type UpdateTemplateConfigToItemResp = {
+  items?: TemplateConfigItem[]
+}
+
+export type GetTemplateConfigVersionsReq = {
+  workspaceId?: number
+}
+
+export type GetTemplateConfigVersionsResp = {
+  versions?: string[]
+}
+
+export type GetTemplateConfigStringResp = {
+  conf?: string
+  fileName?: string
+}
+
+export type DeleteTemplateReq = {
+  workspaceId?: number
+  name?: string
+  version?: string
+}
+
+export type DeleteTemplateConfigResp = {
+  message?: string
+}
+
+export type CreateOrUpdateTemplateConfigResp = {
+  message?: string
+}
+
+export type GetTemplateConfigReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetTemplateConfigReqSortDir
+  sortBy?: string
+  searchKey?: string
+  workspaceId?: number
+  name?: string
+  version?: string
+  templateType?: string
+  type?: string
+  createTimestamp?: string
+  templateInstanceType?: TemplateInstanceType
+}
+
+export type GetTemplateConfigStringReq = {
+  workspaceId?: number
+  name?: string
+}
+
+export type CreateTemplateConfigResp = {
+  message?: string
+}
+
+export type UpdateTemplateConfigResp = {
+  message?: string
+}
+
+export type CreateTemplateConfigReq = {
+  workspaceId?: number
+  targetName?: string
+  targetVersion?: string
+  targetType?: string
+  targetTemplateType?: string
+  targetConf?: string
+  fromTemplateName?: string
+  targetTemplateInstanceType?: TemplateInstanceType
+}
+
+export type UpdateTemplateConfigReq = {
+  workspaceId?: number
+  name?: string
+  version?: string
+  type?: string
+  templateType?: string
+  items?: TemplateConfigItem[]
+  conf?: string
+}
+
+export type GetTemplateConfigResp = {
+  data?: UpdateTemplateConfigReq
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetTemplateConfigListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetTemplateConfigListReqSortDir
+  sortBy?: string
+  searchKey?: string
+  workspaceId?: number
+  version?: string
+  templateInstanceType?: TemplateInstanceType
+}
+
+export type TemplateConfigItem = {
+  name?: string
+  default?: string
+  current?: string
+  value?: string
+  isNeedRestart?: boolean
+  valueType?: TemplateConfigItemValueType
+  valueRemarksZh?: string
+  valueRemarksEn?: string
+  updateTimestamp?: string
+}
+
+export type GetTemplateConfigListResp = {
+  items?: GetTemplateConfigReq[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetTemplateInstanceTypeListReq = {
+  workspaceId?: number
+}
+
+export type GetTemplateInstanceTypeListResp = {
+  type?: TemplateInstanceType[]
+}
+
+export class Template {
+  static GetTemplateConfigList(req: GetTemplateConfigListReq, initReq?: fm.InitReq): Promise<GetTemplateConfigListResp> {
+    return fm.fetchReq<GetTemplateConfigListReq, GetTemplateConfigListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+  static GetTemplateInstanceTypeList(req: GetTemplateInstanceTypeListReq, initReq?: fm.InitReq): Promise<GetTemplateInstanceTypeListResp> {
+    return fm.fetchReq<GetTemplateInstanceTypeListReq, GetTemplateInstanceTypeListResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_instance_type?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+  static GetTemplateConfig(req: GetTemplateConfigReq, initReq?: fm.InitReq): Promise<GetTemplateConfigResp> {
+    return fm.fetchReq<GetTemplateConfigReq, GetTemplateConfigResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config/${req["name"]}?${fm.renderURLSearchParams(req, ["workspaceId", "name"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteTemplateConfig(req: DeleteTemplateReq, initReq?: fm.InitReq): Promise<DeleteTemplateConfigResp> {
+    return fm.fetchReq<DeleteTemplateReq, DeleteTemplateConfigResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config/${req["name"]}/${req["version"]}`, {...initReq, method: "DELETE"})
+  }
+  static CreateTemplateConfig(req: CreateTemplateConfigReq, initReq?: fm.InitReq): Promise<CreateTemplateConfigResp> {
+    return fm.fetchReq<CreateTemplateConfigReq, CreateTemplateConfigResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static UpdateTemplateConfig(req: UpdateTemplateConfigReq, initReq?: fm.InitReq): Promise<UpdateTemplateConfigResp> {
+    return fm.fetchReq<UpdateTemplateConfigReq, UpdateTemplateConfigResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static GetTemplateConfigString(req: GetTemplateConfigStringReq, initReq?: fm.InitReq): Promise<GetTemplateConfigStringResp> {
+    return fm.fetchReq<GetTemplateConfigStringReq, GetTemplateConfigStringResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config/${req["name"]}/to_string?${fm.renderURLSearchParams(req, ["workspaceId", "name"])}`, {...initReq, method: "GET"})
+  }
+  static UpdateTemplateConfigToItem(req: UpdateTemplateConfigToItemReq, initReq?: fm.InitReq): Promise<UpdateTemplateConfigToItemResp> {
+    return fm.fetchReq<UpdateTemplateConfigToItemReq, UpdateTemplateConfigToItemResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config/to_template`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static GetTemplateConfigVersions(req: GetTemplateConfigVersionsReq, initReq?: fm.InitReq): Promise<GetTemplateConfigVersionsResp> {
+    return fm.fetchReq<GetTemplateConfigVersionsReq, GetTemplateConfigVersionsResp>(`/apis/mcamel.io/postgresql/v1alpha1/${req["workspaceId"]}/template_config/versions?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+}

package/version.pb.ts

@@ -17,6 +17,10 @@ export type GetVersionReply = {
   buildTime?: string
 }
 
+export type HealthzReply = {
+  message?: string
+}
+
 export type Empty = {
 }
 
@@ -24,4 +28,7 @@ export class Version {
   static Get(req: Empty, initReq?: fm.InitReq): Promise<GetVersionReply> {
     return fm.fetchReq<Empty, GetVersionReply>(`/apis/mcamel.io/postgresql/v1alpha1/postgresql/version?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
+  static Healthz(req: Empty, initReq?: fm.InitReq): Promise<HealthzReply> {
+    return fm.fetchReq<Empty, HealthzReply>(`/healthz?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
 }