@daocloud-proto/hydra 0.0.0-dev-65873840

package/management-api/storage/v1alpha1/filesstorage.pb.ts

@@ -0,0 +1,495 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as HydraCommonCommon from "../../../common/common.pb"
+import * as fm from "../../../fetch.pb"
+import * as GoogleProtobufEmpty from "../../../google/protobuf/empty.pb"
+import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+import * as HydraStorageserverV1alpha1Storage_server from "../../../storageserver/v1alpha1/storage_server.pb"
+import * as EventV1alpha1Event from "../../event/v1alpha1/event.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 PvcPhase {
+  PvcPhaseUnknown = "PvcPhaseUnknown",
+  PvcPhaseBound = "PvcPhaseBound",
+  PvcPhasePending = "PvcPhasePending",
+  PvcPhaseLost = "PvcPhaseLost",
+  PvcPhaseFailed = "PvcPhaseFailed",
+  PvcPhaseDeleting = "PvcPhaseDeleting",
+}
+
+export enum ListReferencedByRequestItemType {
+  model = "model",
+  dataset = "dataset",
+}
+
+export enum DataSourceType {
+  DATA_SOURCE_TYPE_UNSPECIFIED = "DATA_SOURCE_TYPE_UNSPECIFIED",
+  GIT = "GIT",
+  S3 = "S3",
+  HTTP = "HTTP",
+  HUGGING_FACE = "HUGGING_FACE",
+  MODEL_SCOPE = "MODEL_SCOPE",
+}
+
+export enum SecretOptionsAuthType {
+  AUTH_TYPE_UNSPECIFIED = "AUTH_TYPE_UNSPECIFIED",
+  BASIC = "BASIC",
+  SSH = "SSH",
+  TOKEN = "TOKEN",
+  AK_SK = "AK_SK",
+}
+
+export enum DataSourceOptionsSyncMode {
+  SYNC_MODE_UNSPECIFIED = "SYNC_MODE_UNSPECIFIED",
+  copy = "copy",
+  sync = "sync",
+}
+
+export enum DataSourceOptionsS3Provider {
+  PROVIDER_UNSPECIFIED = "PROVIDER_UNSPECIFIED",
+  AWS = "AWS",
+  MINIO = "MINIO",
+}
+
+export enum DataSourceOptionsHuggingFaceRepoType {
+  REPO_TYPE_UNSPECIFIED = "REPO_TYPE_UNSPECIFIED",
+  MODEL = "MODEL",
+  DATASET = "DATASET",
+}
+
+export enum DataSourceOptionsModelScopeRepoType {
+  REPO_TYPE_UNSPECIFIED = "REPO_TYPE_UNSPECIFIED",
+  MODEL = "MODEL",
+  DATASET = "DATASET",
+}
+
+export enum DatasetStatusPhase {
+  DATA_SET_PHASE_UNSPECIFIED = "DATA_SET_PHASE_UNSPECIFIED",
+  PENDING = "PENDING",
+  READY = "READY",
+  PROCESSING = "PROCESSING",
+  FAILED = "FAILED",
+}
+
+export enum PrePullActionRequestAction {
+  ACTION_UNSPECIFIED = "ACTION_UNSPECIFIED",
+  RERUN = "RERUN",
+}
+
+export type FilesStorageStatus = {
+  phase?: PvcPhase
+  reason?: string
+  pvcName?: string
+  pvcNamespace?: string
+  storageServer?: StorageServerStatus
+}
+
+export type FilesStorage = {
+  name?: string
+  cluster?: string
+  pvcNamespace?: string
+  storageClassName?: string
+  capacity?: string
+  status?: FilesStorageStatus
+  createTime?: GoogleProtobufTimestamp.Timestamp
+  workspace?: number
+  description?: string
+}
+
+export type StorageServerStatus = {
+  phase?: string
+  name?: string
+  namespace?: string
+}
+
+export type ListFilesStoragesRequest = {
+  workspace?: number
+  page?: HydraCommonCommon.Pagination
+  cluster?: string
+}
+
+export type ListFilesStoragesResponse = {
+  items?: FilesStorage[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type GetFilesStorageRequest = {
+  workspace?: number
+  name?: string
+}
+
+export type CreateFilesStorageRequest = {
+  workspace?: number
+  cluster?: string
+  description?: string
+}
+
+export type UpdateFilesStorageRequest = {
+  workspace?: number
+  name?: string
+  description?: string
+}
+
+export type DeleteFilesStorageRequest = {
+  workspace?: number
+  name?: string
+}
+
+export type FileInfo = {
+  name?: string
+  type?: HydraStorageserverV1alpha1Storage_server.FileType
+  size?: string
+  modificationTimestamp?: string
+}
+
+export type ListFilesRequest = {
+  workspace?: number
+  name?: string
+  path?: string
+  type?: HydraStorageserverV1alpha1Storage_server.FileType
+  searchKeyword?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListFilesResponse = {
+  files?: FileInfo[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type CreateFolderRequest = {
+  workspace?: number
+  name?: string
+  folderName?: string
+  path?: string
+}
+
+export type DeleteFileRequest = {
+  workspace?: number
+  name?: string
+  fileName?: string
+  path?: string
+}
+
+export type ListReferencedByRequest = {
+  workspace?: number
+  name?: string
+  itemType?: ListReferencedByRequestItemType
+}
+
+export type ListReferencedByResponseReferencedItem = {
+  id?: string
+  name?: string
+}
+
+export type ListReferencedByResponse = {
+  items?: ListReferencedByResponseReferencedItem[]
+}
+
+export type DataSource = {
+  type?: DataSourceType
+  uri?: string
+  options?: DataSourceOptions
+}
+
+export type SecretOptionsBasicAuth = {
+  username?: string
+  password?: string
+}
+
+export type SecretOptionsSSHAuth = {
+  privateKey?: string
+  passphrase?: string
+}
+
+export type SecretOptionsTokenAuth = {
+  token?: string
+}
+
+export type SecretOptionsAkSkAuth = {
+  accessKey?: string
+  secretKey?: string
+}
+
+
+/* hydra modified */ export type BaseSecretOptions = {
+  authType?: SecretOptionsAuthType
+}
+
+export type SecretOptions = BaseSecretOptions
+  & OneOf<{ basic: SecretOptionsBasicAuth; ssh: SecretOptionsSSHAuth; token: SecretOptionsTokenAuth; akSk: SecretOptionsAkSkAuth }>
+
+export type DataSourceOptionsGit = {
+  branch?: string
+  commit?: string
+  depth?: number
+  submodules?: boolean
+}
+
+export type DataSourceOptionsS3 = {
+  region?: string
+  endpoint?: string
+  provider?: DataSourceOptionsS3Provider
+  syncMode?: DataSourceOptionsSyncMode
+}
+
+export type DataSourceOptionsHttp = {
+  headers?: {[key: string]: string}
+  syncMode?: DataSourceOptionsSyncMode
+}
+
+
+/* hydra modified */ export type BaseDataSourceOptions = {
+}
+
+export type DataSourceOptions = BaseDataSourceOptions
+  & OneOf<{ git: DataSourceOptionsGit; s3: DataSourceOptionsS3; http: DataSourceOptionsHttp; huggingFace: DataSourceOptionsHuggingFace; modelScope: DataSourceOptionsModelScope }>
+
+export type DataSourceOptionsHuggingFace = {
+  endpoint?: string
+  include?: string
+  exclude?: string
+  revision?: string
+  repoType?: DataSourceOptionsHuggingFaceRepoType
+}
+
+export type DataSourceOptionsModelScope = {
+  include?: string
+  exclude?: string
+  revision?: string
+  repoType?: DataSourceOptionsModelScopeRepoType
+}
+
+export type DatasetStatus = {
+  phase?: DatasetStatusPhase
+}
+
+export type PrePull = {
+  name?: string
+  cluster?: string
+  namespace?: string
+  path?: string
+  storageName?: string
+  description?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  labels?: {[key: string]: string}
+  annotations?: {[key: string]: string}
+  source?: DataSource
+  status?: DatasetStatus
+  lastSync?: GoogleProtobufTimestamp.Timestamp
+  secretRef?: string
+  workspace?: number
+}
+
+export type ListPrePullsRequest = {
+  storageName?: string
+  workspace?: number
+  cluster?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListPrePullsResponse = {
+  items?: PrePull[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type CreatePrePullRequest = {
+  prepullName?: string
+  cluster?: string
+  path?: string
+  storageName?: string
+  description?: string
+  labels?: {[key: string]: string}
+  annotations?: {[key: string]: string}
+  source?: DataSource
+  secretOptions?: SecretOptions
+  workspace?: number
+}
+
+
+/* hydra modified */ export type BaseUpdatePrePullRequest = {
+  cluster?: string
+  storageName?: string
+  prepullName?: string
+  description?: string
+  labels?: {[key: string]: string}
+  annotations?: {[key: string]: string}
+  secretOptions?: SecretOptions
+  workspace?: number
+  path?: string
+}
+
+export type UpdatePrePullRequest = BaseUpdatePrePullRequest
+  & OneOf<{ git: DataSourceOptionsGit; s3: DataSourceOptionsS3; http: DataSourceOptionsHttp; huggingFace: DataSourceOptionsHuggingFace; modelScope: DataSourceOptionsModelScope }>
+
+export type DeletePrePullRequest = {
+  storageName?: string
+  prepullName?: string
+  workspace?: number
+}
+
+export type PrePullActionRequest = {
+  cluster?: string
+  storageName?: string
+  prepullName?: string
+  action?: PrePullActionRequestAction
+  workspace?: number
+}
+
+export type ValidateDataSourceSecretsRequest = {
+  source?: DataSource
+  secretOptions?: SecretOptions
+  workspace?: number
+}
+
+export type ValidateDataSourceSecretsResponse = {
+  valid?: boolean
+  message?: string
+}
+
+export type ListDatasetEventsRequest = {
+  cluster?: string
+  storageName?: string
+  prepullName?: string
+  page?: HydraCommonCommon.Pagination
+  workspace?: number
+}
+
+export type SinglePrePullRequest = {
+  cluster?: string
+  storageName?: string
+  prepullName?: string
+  workspace?: number
+}
+
+export type PrePullSyncProcess = {
+  status?: DatasetStatus
+  syncProcess?: number
+}
+
+export type PodRequest = {
+  workspace?: number
+  storageName?: string
+  prepullName?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type PodInstance = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  phase?: string
+  containerReadyCount?: number
+  containerTotalCount?: number
+  podIp?: string
+  nodeName?: string
+  containers?: Container[]
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type Container = {
+  name?: string
+}
+
+export type PodInstanceListResponse = {
+  items?: PodInstance[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type GetPrePullRequest = {
+  workspace?: number
+  storageName?: string
+  prepullName?: string
+}
+
+export type CreateSFTPAccessRequest = {
+  workspace?: number
+  storageName?: string
+  expirationDays?: number
+}
+
+export type GetSFTPAccessRequest = {
+  workspace?: number
+  storageName?: string
+}
+
+export type SFTPAccessResponse = {
+  command?: string
+}
+
+export class WSFilesStorageService {
+  static ListWSFilesStorages(req: ListFilesStoragesRequest, initReq?: fm.InitReq): Promise<ListFilesStoragesResponse> {
+    return fm.fetchReq<ListFilesStoragesRequest, ListFilesStoragesResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static GetWSFilesStorage(req: GetFilesStorageRequest, initReq?: fm.InitReq): Promise<FilesStorage> {
+    return fm.fetchReq<GetFilesStorageRequest, FilesStorage>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static CreateWSFilesStorage(req: CreateFilesStorageRequest, initReq?: fm.InitReq): Promise<FilesStorage> {
+    return fm.fetchReq<CreateFilesStorageRequest, FilesStorage>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdateWSFilesStorage(req: UpdateFilesStorageRequest, initReq?: fm.InitReq): Promise<FilesStorage> {
+    return fm.fetchReq<UpdateFilesStorageRequest, FilesStorage>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["name"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DeleteWSFilesStorage(req: DeleteFilesStorageRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<DeleteFilesStorageRequest, GoogleProtobufEmpty.Empty>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+  static ListWSFiles(req: ListFilesRequest, initReq?: fm.InitReq): Promise<ListFilesResponse> {
+    return fm.fetchReq<ListFilesRequest, ListFilesResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["name"]}/files?${fm.renderURLSearchParams(req, ["workspace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteWSFile(req: DeleteFileRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<DeleteFileRequest, GoogleProtobufEmpty.Empty>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["name"]}/files/${req["fileName"]}:delete`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static CreateWSFolder(req: CreateFolderRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<CreateFolderRequest, GoogleProtobufEmpty.Empty>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["name"]}/folders/${req["folderName"]}`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static ListWSReferencedBy(req: ListReferencedByRequest, initReq?: fm.InitReq): Promise<ListReferencedByResponse> {
+    return fm.fetchReq<ListReferencedByRequest, ListReferencedByResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["name"]}/referencedby/${req["itemType"]}?${fm.renderURLSearchParams(req, ["workspace", "name", "itemType"])}`, {...initReq, method: "GET"})
+  }
+  static WSListPrePulls(req: ListPrePullsRequest, initReq?: fm.InitReq): Promise<ListPrePullsResponse> {
+    return fm.fetchReq<ListPrePullsRequest, ListPrePullsResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls?${fm.renderURLSearchParams(req, ["workspace", "storageName"])}`, {...initReq, method: "GET"})
+  }
+  static WSCreatePrePull(req: CreatePrePullRequest, initReq?: fm.InitReq): Promise<PrePull> {
+    return fm.fetchReq<CreatePrePullRequest, PrePull>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static WSUpdatePrePull(req: UpdatePrePullRequest, initReq?: fm.InitReq): Promise<PrePull> {
+    return fm.fetchReq<UpdatePrePullRequest, PrePull>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls/${req["prepullName"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static WSDeletePrePull(req: DeletePrePullRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<DeletePrePullRequest, GoogleProtobufEmpty.Empty>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls/${req["prepullName"]}`, {...initReq, method: "DELETE"})
+  }
+  static WSDatasetDoAction(req: PrePullActionRequest, initReq?: fm.InitReq): Promise<PrePull> {
+    return fm.fetchReq<PrePullActionRequest, PrePull>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls/${req["prepullName"]}/actions`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static WSListPrePullEvents(req: ListDatasetEventsRequest, initReq?: fm.InitReq): Promise<EventV1alpha1Event.ListEventsResponse> {
+    return fm.fetchReq<ListDatasetEventsRequest, EventV1alpha1Event.ListEventsResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls/${req["prepullName"]}/events?${fm.renderURLSearchParams(req, ["workspace", "storageName", "prepullName"])}`, {...initReq, method: "GET"})
+  }
+  static WSGetPrePullSyncProcess(req: SinglePrePullRequest, initReq?: fm.InitReq): Promise<PrePullSyncProcess> {
+    return fm.fetchReq<SinglePrePullRequest, PrePullSyncProcess>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls/${req["prepullName"]}/sync-process?${fm.renderURLSearchParams(req, ["workspace", "storageName", "prepullName"])}`, {...initReq, method: "GET"})
+  }
+  static WSValidateDataSourceSecrets(req: ValidateDataSourceSecretsRequest, initReq?: fm.InitReq): Promise<ValidateDataSourceSecretsResponse> {
+    return fm.fetchReq<ValidateDataSourceSecretsRequest, ValidateDataSourceSecretsResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/validate-secrets`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static WSGetPodInstanceList(req: PodRequest, initReq?: fm.InitReq): Promise<PodInstanceListResponse> {
+    return fm.fetchReq<PodRequest, PodInstanceListResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls/${req["prepullName"]}/pods?${fm.renderURLSearchParams(req, ["workspace", "storageName", "prepullName"])}`, {...initReq, method: "GET"})
+  }
+  static WSGetPrePull(req: GetPrePullRequest, initReq?: fm.InitReq): Promise<PrePull> {
+    return fm.fetchReq<GetPrePullRequest, PrePull>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/prepulls/${req["prepullName"]}?${fm.renderURLSearchParams(req, ["workspace", "storageName", "prepullName"])}`, {...initReq, method: "GET"})
+  }
+  static WSCreateSFTPAccess(req: CreateSFTPAccessRequest, initReq?: fm.InitReq): Promise<SFTPAccessResponse> {
+    return fm.fetchReq<CreateSFTPAccessRequest, SFTPAccessResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/sftp-access`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static WSGetSFTPAccess(req: GetSFTPAccessRequest, initReq?: fm.InitReq): Promise<SFTPAccessResponse> {
+    return fm.fetchReq<GetSFTPAccessRequest, SFTPAccessResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/filesstorages/${req["storageName"]}/sftp-access?${fm.renderURLSearchParams(req, ["workspace", "storageName"])}`, {...initReq, method: "GET"})
+  }
+}

package/management-api/user/v1alpha1/user.pb.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as fm from "../../../fetch.pb"
+export type CurrentUserRequest = {
+}
+
+export type UserInfo = {
+  id?: string
+  username?: string
+  balance?: string
+  amount?: string
+  idVerified?: boolean
+  isMain?: boolean
+}
+
+export class UserService {
+  static CurrentUser(req: CurrentUserRequest, initReq?: fm.InitReq): Promise<UserInfo> {
+    return fm.fetchReq<CurrentUserRequest, UserInfo>(`/apis/hydra.io/v1alpha1/current-user?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}

package/management-api/web_search_agent/v1alpha1/agent.pb.ts

@@ -0,0 +1,19 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as fm from "../../../fetch.pb"
+export type GetAgentAddressRequest = {
+}
+
+export type GetAgentAddressResponse = {
+  address?: string
+}
+
+export class WebSearchAgentService {
+  static GetAgentAddress(req: GetAgentAddressRequest, initReq?: fm.InitReq): Promise<GetAgentAddressResponse> {
+    return fm.fetchReq<GetAgentAddressRequest, GetAgentAddressResponse>(`/apis/hydra.io/v1alpha1/web-search-agent/address?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}

package/management-api/workspace/v1alpha1/workspace.pb.ts

@@ -0,0 +1,82 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as HydraCommonCommon from "../../../common/common.pb"
+import * as fm from "../../../fetch.pb"
+
+export enum ClusterStatus {
+  STATUS_UNSPECIFIED = "STATUS_UNSPECIFIED",
+  STATUS_READY = "STATUS_READY",
+  STATUS_NOT_READY = "STATUS_NOT_READY",
+}
+
+export type ListWorkspaceRequest = {
+  page?: HydraCommonCommon.Pagination
+  cluster?: string
+}
+
+export type Workspace = {
+  workspaceId?: number
+  alias?: string
+}
+
+export type ListWorkspacesResponse = {
+  items?: Workspace[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListClusterRequest = {
+  workspace?: number
+  page?: HydraCommonCommon.Pagination
+}
+
+export type Cluster = {
+  name?: string
+  status?: ClusterStatus
+  agentInstalled?: boolean
+  baseUrl?: string
+  components?: Component[]
+}
+
+export type Component = {
+  name?: string
+  installedVersion?: string
+  recommendedVersion?: string
+  ready?: boolean
+}
+
+export type ListClustersResponse = {
+  items?: Cluster[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ClusterNamespace = {
+  cluster?: string
+  namespace?: string
+}
+
+export type ListClusterNamespacesRequest = {
+  workspace?: number
+  cluster?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListClusterNamespaceResponse = {
+  items?: ClusterNamespace[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export class WorkspaceService {
+  static ListWorkspaces(req: ListWorkspaceRequest, initReq?: fm.InitReq): Promise<ListWorkspacesResponse> {
+    return fm.fetchReq<ListWorkspaceRequest, ListWorkspacesResponse>(`/apis/hydra.io/v1alpha1/workspaces?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static ListClusters(req: ListClusterRequest, initReq?: fm.InitReq): Promise<ListClustersResponse> {
+    return fm.fetchReq<ListClusterRequest, ListClustersResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/clusters?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static ListClusterNamespaces(req: ListClusterNamespacesRequest, initReq?: fm.InitReq): Promise<ListClusterNamespaceResponse> {
+    return fm.fetchReq<ListClusterNamespacesRequest, ListClusterNamespaceResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/cluster-namespaces?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+}

package/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@daocloud-proto/hydra",
+  "version": "v0.0.0-dev-65873840",
+  "description": "",
+  "author": "",
+  "license": "ISC"
+}