@daocloud-proto/hydra 0.11.0 → 0.15.0-dev-2

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

@@ -7,6 +7,16 @@
 import * as HydraCommonCommon from "../../../common/common.pb"
 import * as fm from "../../../fetch.pb"
 import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+import * as HydraManagement_apiModel_typeV1alpha1Model_type from "../../model_type/v1alpha1/model_type.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 TimePeriod {
   TIME_PERIOD_UNSPECIFIED = "TIME_PERIOD_UNSPECIFIED",
@@ -16,15 +26,25 @@ export enum TimePeriod {
   TIME_PERIOD_MONTH = "TIME_PERIOD_MONTH",
 }
 
-export type CreateWSAPIKeyRequest = {
+
+/* hydra modified */ export type BaseCreateWSAPIKeyRequest = {
   name?: string
   workspace?: number
+  quota?: string
+  unlimitedQuota?: boolean
 }
 
-export type CreateAPIKeyRequest = {
+export type CreateWSAPIKeyRequest = BaseCreateWSAPIKeyRequest
+  & OneOf<{ expireTime: GoogleProtobufTimestamp.Timestamp }>
+
+
+/* hydra modified */ export type BaseCreateAPIKeyRequest = {
   name?: string
 }
 
+export type CreateAPIKeyRequest = BaseCreateAPIKeyRequest
+  & OneOf<{ expireTime: GoogleProtobufTimestamp.Timestamp }>
+
 export type APIKey = {
   id?: string
   key?: string
@@ -35,6 +55,15 @@ export type APIKey = {
   denyModels?: string[]
   workspace?: number
   createBy?: string
+  quota?: string
+  expireTime?: GoogleProtobufTimestamp.Timestamp
+  remainingQuota?: string
+  remainingQuotaSyncedAt?: GoogleProtobufTimestamp.Timestamp
+  unlimitedQuota?: boolean
+  usedQuota?: string
+  lastUsedTime?: GoogleProtobufTimestamp.Timestamp
+  expired?: boolean
+  disabled?: boolean
 }
 
 export type ListWSAPIKeyRequest = {
@@ -56,10 +85,31 @@ export type DeleteWSAPIKeyRequest = {
   workspace?: number
 }
 
+export type UpdateWSAPIKeyQuotaRequest = {
+  id?: string
+  workspace?: number
+  quota?: string
+  unlimitedQuota?: boolean
+}
+
+export type UpdateWSAPIKeyStatusRequest = {
+  id?: string
+  workspace?: number
+  disabled?: boolean
+}
+
 export type DeleteAPIKeyRequest = {
   id?: string
 }
 
+export type CheckAPIKeyCreationRequest = {
+}
+
+export type CheckAPIKeyCreationResponse = {
+  allowed?: boolean
+  reason?: string
+}
+
 export type WSAPIKeyUsageStatisticsRequest = {
   startTime?: GoogleProtobufTimestamp.Timestamp
   endTime?: GoogleProtobufTimestamp.Timestamp
@@ -86,12 +136,18 @@ export type Usage = {
   total?: string
   input?: string
   output?: string
+  cached?: string
+  inputCharacters?: string
+  outputAudioDuration?: string
+  sampleRate?: number
+  inputAudioDuration?: string
 }
 
 export type DataPoint = {
   timestamp?: GoogleProtobufTimestamp.Timestamp
   usage?: Usage
   model?: string
+  modelType?: HydraManagement_apiModel_typeV1alpha1Model_type.RequestModelType
 }
 
 export class APIKeyManagement {
@@ -107,6 +163,9 @@ export class APIKeyManagement {
   static GetAPIKeyUsageStatistics(req: APIKeyUsageStatisticsRequest, initReq?: fm.InitReq): Promise<APIKeyUsageStatisticsResponse> {
     return fm.fetchReq<APIKeyUsageStatisticsRequest, APIKeyUsageStatisticsResponse>(`/apis/hydra.io/v1alpha1/apikeys-stats`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }
+  static CheckAPIKeyCreation(req: CheckAPIKeyCreationRequest, initReq?: fm.InitReq): Promise<CheckAPIKeyCreationResponse> {
+    return fm.fetchReq<CheckAPIKeyCreationRequest, CheckAPIKeyCreationResponse>(`/apis/hydra.io/v1alpha1/apikeys/check-creation`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
 }
 export class WSAPIKeyManagement {
   static CreateWSAPIKey(req: CreateWSAPIKeyRequest, initReq?: fm.InitReq): Promise<APIKey> {
@@ -115,9 +174,18 @@ export class WSAPIKeyManagement {
   static ListWSAPIKey(req: ListWSAPIKeyRequest, initReq?: fm.InitReq): Promise<ListAPIKeyResponse> {
     return fm.fetchReq<ListWSAPIKeyRequest, ListAPIKeyResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/apikeys?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
   }
+  static ListMyWSAPIKeys(req: ListWSAPIKeyRequest, initReq?: fm.InitReq): Promise<ListAPIKeyResponse> {
+    return fm.fetchReq<ListWSAPIKeyRequest, ListAPIKeyResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/my-apikeys?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
   static DeleteWSAPIKey(req: DeleteWSAPIKeyRequest, initReq?: fm.InitReq): Promise<APIKey> {
     return fm.fetchReq<DeleteWSAPIKeyRequest, APIKey>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/apikeys/${req["id"]}`, {...initReq, method: "DELETE", body: JSON.stringify(req, fm.replacer)})
   }
+  static UpdateWSAPIKeyStatus(req: UpdateWSAPIKeyStatusRequest, initReq?: fm.InitReq): Promise<APIKey> {
+    return fm.fetchReq<UpdateWSAPIKeyStatusRequest, APIKey>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/apikeys/${req["id"]}/status`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdateWSAPIKeyQuota(req: UpdateWSAPIKeyQuotaRequest, initReq?: fm.InitReq): Promise<APIKey> {
+    return fm.fetchReq<UpdateWSAPIKeyQuotaRequest, APIKey>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/apikeys/${req["id"]}/quota`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
   static GetAPIKeyUsageStatistics(req: WSAPIKeyUsageStatisticsRequest, initReq?: fm.InitReq): Promise<APIKeyUsageStatisticsResponse> {
     return fm.fetchReq<WSAPIKeyUsageStatisticsRequest, APIKeyUsageStatisticsResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/apikeys-stats`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as fm from "../../../fetch.pb"
+
+export enum Prerequisite {
+  PREREQUISITE_UNSPECIFIED = "PREREQUISITE_UNSPECIFIED",
+  PREREQUISITE_PREFLIGHT = "PREREQUISITE_PREFLIGHT",
+}
+
+export type GetPrerequisiteRequest = {
+  workspace?: number
+  cluster?: string
+  prerequisite?: Prerequisite
+}
+
+export type GetPrerequisiteResponse = {
+  ok?: boolean
+}
+
+export class Cluster {
+  static GetPrerequisite(req: GetPrerequisiteRequest, initReq?: fm.InitReq): Promise<GetPrerequisiteResponse> {
+    return fm.fetchReq<GetPrerequisiteRequest, GetPrerequisiteResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/prerequisites/${req["prerequisite"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "prerequisite"])}`, {...initReq, method: "GET"})
+  }
+}

package/management-api/core/v1alpha1/image.pb.ts

@@ -0,0 +1,174 @@
+/* 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 GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+
+export enum RegistryType {
+  REGISTRY_TYPE_UNSPECIFIED = "REGISTRY_TYPE_UNSPECIFIED",
+  REGISTRY_TYPE_HARBOR = "REGISTRY_TYPE_HARBOR",
+  REGISTRY_TYPE_DOCKER = "REGISTRY_TYPE_DOCKER",
+  REGISTRY_TYPE_JFROG = "REGISTRY_TYPE_JFROG",
+}
+
+export enum Scope {
+  SCOPE_UNKNOWN = "SCOPE_UNKNOWN",
+  SCOPE_GLOBAL = "SCOPE_GLOBAL",
+  SCOPE_WORKSPACE = "SCOPE_WORKSPACE",
+}
+
+export enum Visibility {
+  VISIBLE_UNKNOWN = "VISIBLE_UNKNOWN",
+  VISIBLE_PUBLIC = "VISIBLE_PUBLIC",
+  VISIBLE_PRIVATE = "VISIBLE_PRIVATE",
+}
+
+export type ListRegistriesRequest = {
+  workspace?: number
+  global?: boolean
+  page?: HydraCommonCommon.Pagination
+}
+
+export type Registry = {
+  host?: string
+  name?: string
+  type?: RegistryType
+  scope?: Scope
+}
+
+export type ListRegistriesResponse = {
+  items?: Registry[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListProjectsRequest = {
+  workspace?: number
+  registry?: string
+  public?: boolean
+  page?: HydraCommonCommon.Pagination
+  onlyBind?: boolean
+  all?: boolean
+}
+
+export type Project = {
+  name?: string
+  visible?: Visibility
+}
+
+export type ListProjectsResponse = {
+  items?: Project[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListRepositoriesRequest = {
+  workspace?: number
+  registry?: string
+  project?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type Tag = {
+  name?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type Repository = {
+  name?: string
+  updateTimestamp?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type ListRepositoriesResponse = {
+  items?: Repository[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListArtifactsRequest = {
+  workspace?: number
+  registry?: string
+  project?: string
+  repository?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type Artifact = {
+  digest?: string
+  tags?: Tag[]
+  imageSize?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type ListArtifactsResponse = {
+  items?: Artifact[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type GetImageInfoRequest = {
+  workspace?: number
+  image?: string
+}
+
+export type ImageInfo = {
+  registry?: string
+  project?: string
+  image?: string
+  tag?: string
+  public?: boolean
+  global?: boolean
+}
+
+export type GetImageInfoResponse = {
+  origin?: string
+  info?: ImageInfo
+}
+
+export type ListSecretsRequest = {
+  cluster?: string
+  namespace?: string
+  type?: string
+}
+
+export type Secret = {
+  name?: string
+  namespace?: string
+  cluster?: string
+  type?: string
+}
+
+export type ListSecretsResponse = {
+  items?: Secret[]
+}
+
+export type DetectKangarooRequest = {
+}
+
+export type DetectKangarooResponse = {
+  enabled?: boolean
+}
+
+export class Image {
+  static ListRegistries(req: ListRegistriesRequest, initReq?: fm.InitReq): Promise<ListRegistriesResponse> {
+    return fm.fetchReq<ListRegistriesRequest, ListRegistriesResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/registries?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static ListProjects(req: ListProjectsRequest, initReq?: fm.InitReq): Promise<ListProjectsResponse> {
+    return fm.fetchReq<ListProjectsRequest, ListProjectsResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/registries/${req["registry"]}/projects?${fm.renderURLSearchParams(req, ["workspace", "registry"])}`, {...initReq, method: "GET"})
+  }
+  static ListRepositories(req: ListRepositoriesRequest, initReq?: fm.InitReq): Promise<ListRepositoriesResponse> {
+    return fm.fetchReq<ListRepositoriesRequest, ListRepositoriesResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/registries/${req["registry"]}/repositories?${fm.renderURLSearchParams(req, ["workspace", "registry"])}`, {...initReq, method: "GET"})
+  }
+  static ListArtifacts(req: ListArtifactsRequest, initReq?: fm.InitReq): Promise<ListArtifactsResponse> {
+    return fm.fetchReq<ListArtifactsRequest, ListArtifactsResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/registries/${req["registry"]}/repositories/${req["repository"]}/artifacts?${fm.renderURLSearchParams(req, ["workspace", "registry", "repository"])}`, {...initReq, method: "GET"})
+  }
+  static ListSecrets(req: ListSecretsRequest, initReq?: fm.InitReq): Promise<ListSecretsResponse> {
+    return fm.fetchReq<ListSecretsRequest, ListSecretsResponse>(`/apis/hydra.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/secrets?${fm.renderURLSearchParams(req, ["cluster", "namespace"])}`, {...initReq, method: "GET"})
+  }
+  static GetImageInfo(req: GetImageInfoRequest, initReq?: fm.InitReq): Promise<GetImageInfoResponse> {
+    return fm.fetchReq<GetImageInfoRequest, GetImageInfoResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/imageinfo?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static DetectKangaroo(req: DetectKangarooRequest, initReq?: fm.InitReq): Promise<DetectKangarooResponse> {
+    return fm.fetchReq<DetectKangarooRequest, DetectKangarooResponse>(`/apis/hydra.io/v1alpha1/registries/kangaroo?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}

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

@@ -26,6 +26,20 @@ export type ListInferenceRuntimesResponse = {
 
 export type InferenceRuntime = {
   name?: HydraCommonCommon.I18nName
+  runtimeCommand?: string
+  distributedSupported?: boolean
+}
+
+export type ListGPUTypesRequest = {
+}
+
+export type ListGPUTypesResponse = {
+  items?: GPUType[]
+}
+
+export type GPUType = {
+  gpuName?: string
+  gpuType?: string
 }
 
 export class Management {
@@ -35,4 +49,7 @@ export class Management {
   static ListInferenceRuntimes(req: ListInferenceRuntimesRequest, initReq?: fm.InitReq): Promise<ListInferenceRuntimesResponse> {
     return fm.fetchReq<ListInferenceRuntimesRequest, ListInferenceRuntimesResponse>(`/apis/hydra.io/v1alpha1/inference-runtimes?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
+  static ListGPUTypes(req: ListGPUTypesRequest, initReq?: fm.InitReq): Promise<ListGPUTypesResponse> {
+    return fm.fetchReq<ListGPUTypesRequest, ListGPUTypesResponse>(`/apis/hydra.io/v1alpha1/gpu-types?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
 }

package/management-api/core/v1alpha1/permissions.pb.ts

@@ -5,26 +5,48 @@
 */
 
 import * as fm from "../../../fetch.pb"
-export type ListRolePermissionsByWorkspaceForCurrentUserRequest = {
-  workspace?: number
-}
 
-export type ListRolePermissionsByWorkspaceForCurrentUserResponse = {
-  permissions?: string[]
+export enum UserPermission {
+  MODEL_GET = "MODEL_GET",
+  MODEL_CREATE = "MODEL_CREATE",
+  MODEL_UPDATE = "MODEL_UPDATE",
+  MODEL_DELETE = "MODEL_DELETE",
+  MODEL_SERVING_GET = "MODEL_SERVING_GET",
+  MODEL_SERVING_CREATE = "MODEL_SERVING_CREATE",
+  MODEL_SERVING_UPDATE = "MODEL_SERVING_UPDATE",
+  MODEL_SERVING_DELETE = "MODEL_SERVING_DELETE",
+  APIKEY_GET = "APIKEY_GET",
+  APIKEY_CREATE = "APIKEY_CREATE",
+  APIKEY_DELETE = "APIKEY_DELETE",
+  CLUSTER_GET = "CLUSTER_GET",
+  FILES_STORAGE_GET = "FILES_STORAGE_GET",
+  FILES_STORAGE_CREATE = "FILES_STORAGE_CREATE",
+  FILES_STORAGE_UPDATE = "FILES_STORAGE_UPDATE",
+  FILES_STORAGE_DELETE = "FILES_STORAGE_DELETE",
+  QUEUE_GET = "QUEUE_GET",
+  QUEUE_CREATE = "QUEUE_CREATE",
+  QUEUE_UPDATE = "QUEUE_UPDATE",
+  QUEUE_DELETE = "QUEUE_DELETE",
+  DATASET_GET = "DATASET_GET",
+  DATASET_CREATE = "DATASET_CREATE",
+  DATASET_UPDATE = "DATASET_UPDATE",
+  DATASET_DELETE = "DATASET_DELETE",
+  FINETUNE_GET = "FINETUNE_GET",
+  FINETUNE_CREATE = "FINETUNE_CREATE",
+  FINETUNE_UPDATE = "FINETUNE_UPDATE",
+  FINETUNE_DELETE = "FINETUNE_DELETE",
 }
 
-export type ListPlatformRolePermissionsForCurrentUserRequest = {
+export type ListRolePermissionsByWorkspaceForCurrentUserRequest = {
+  workspace?: number
 }
 
-export type ListPlatformRolePermissionsForCurrentUserResponse = {
-  permissions?: string[]
+export type ListRolePermissionsByWorkspaceForCurrentUserResponse = {
+  permissions?: UserPermission[]
 }
 
 export class Core {
   static ListRolePermissionsByWorkspaceForCurrentUser(req: ListRolePermissionsByWorkspaceForCurrentUserRequest, initReq?: fm.InitReq): Promise<ListRolePermissionsByWorkspaceForCurrentUserResponse> {
     return fm.fetchReq<ListRolePermissionsByWorkspaceForCurrentUserRequest, ListRolePermissionsByWorkspaceForCurrentUserResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/permissions?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
   }
-  static ListPlatformRolePermissionsForCurrentUser(req: ListPlatformRolePermissionsForCurrentUserRequest, initReq?: fm.InitReq): Promise<ListPlatformRolePermissionsForCurrentUserResponse> {
-    return fm.fetchReq<ListPlatformRolePermissionsForCurrentUserRequest, ListPlatformRolePermissionsForCurrentUserResponse>(`/apis/hydra.io/v1alpha1/permissions?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
-  }
 }

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

@@ -0,0 +1,110 @@
+/* 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 GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+
+export enum DatasetFramework {
+  DATASET_FRAMEWORK_UNSPECIFIED = "DATASET_FRAMEWORK_UNSPECIFIED",
+  DATASET_FRAMEWORK_LLAMAFACTORY = "DATASET_FRAMEWORK_LLAMAFACTORY",
+}
+
+export enum DatasetFormat {
+  DATASET_FORMAT_UNSPECIFIED = "DATASET_FORMAT_UNSPECIFIED",
+  DATASET_FORMAT_ALPACA = "DATASET_FORMAT_ALPACA",
+  DATASET_FORMAT_SHAREGPT = "DATASET_FORMAT_SHAREGPT",
+}
+
+export enum DatasetUsageType {
+  DATASET_USAGE_TYPE_UNSPECIFIED = "DATASET_USAGE_TYPE_UNSPECIFIED",
+  DATASET_USAGE_TYPE_SFT = "DATASET_USAGE_TYPE_SFT",
+  DATASET_USAGE_TYPE_KTO = "DATASET_USAGE_TYPE_KTO",
+  DATASET_USAGE_TYPE_PREFERENCE = "DATASET_USAGE_TYPE_PREFERENCE",
+}
+
+export type GetDatasetTemplateResponse = {
+  templateJson?: string
+}
+
+export type ListWSDatasetRequest = {
+  workspace?: number
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListWSDatasetResponse = {
+  items?: WSDataset[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type SingleWSDatasetRequest = {
+  workspace?: number
+  datasetId?: string
+}
+
+export type GetWSDatasetTemplateRequest = {
+  workspace?: number
+  framework?: DatasetFramework
+  format?: DatasetFormat
+  usageType?: DatasetUsageType
+}
+
+export type WSDataset = {
+  datasetId?: string
+  datasetAvatar?: string
+  datasetName?: string
+  providerId?: string
+  providerName?: HydraCommonCommon.I18nName
+  datasetDescription?: HydraCommonCommon.I18nName
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  updateTimestamp?: GoogleProtobufTimestamp.Timestamp
+  readme?: HydraCommonCommon.I18nName
+  visible?: string
+  source?: string
+}
+
+export type CreatePrivateDatasetRequest = {
+  workspace?: number
+  datasetAvatar?: string
+  datasetName?: string
+  datasetDescription?: HydraCommonCommon.I18nName
+  readme?: HydraCommonCommon.I18nName
+}
+
+export type UpdatePrivateDatasetRequest = {
+  workspace?: number
+  datasetId?: string
+  datasetAvatar?: string
+  datasetName?: string
+  datasetDescription?: HydraCommonCommon.I18nName
+  readme?: HydraCommonCommon.I18nName
+}
+
+export type ListPrivateDatasetRequest = {
+  workspace?: number
+  page?: HydraCommonCommon.Pagination
+}
+
+export class WSDatasetManagement {
+  static GetWSDatasetTemplate(req: GetWSDatasetTemplateRequest, initReq?: fm.InitReq): Promise<GetDatasetTemplateResponse> {
+    return fm.fetchReq<GetWSDatasetTemplateRequest, GetDatasetTemplateResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/datasets:template?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static ListPrivateDatasets(req: ListPrivateDatasetRequest, initReq?: fm.InitReq): Promise<ListWSDatasetResponse> {
+    return fm.fetchReq<ListPrivateDatasetRequest, ListWSDatasetResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-datasets?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static GetPrivateDataset(req: SingleWSDatasetRequest, initReq?: fm.InitReq): Promise<WSDataset> {
+    return fm.fetchReq<SingleWSDatasetRequest, WSDataset>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-datasets/${req["datasetId"]}?${fm.renderURLSearchParams(req, ["workspace", "datasetId"])}`, {...initReq, method: "GET"})
+  }
+  static CreatePrivateDataset(req: CreatePrivateDatasetRequest, initReq?: fm.InitReq): Promise<WSDataset> {
+    return fm.fetchReq<CreatePrivateDatasetRequest, WSDataset>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-datasets`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdatePrivateDataset(req: UpdatePrivateDatasetRequest, initReq?: fm.InitReq): Promise<WSDataset> {
+    return fm.fetchReq<UpdatePrivateDatasetRequest, WSDataset>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-datasets/${req["datasetId"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DeletePrivateDataset(req: SingleWSDatasetRequest, initReq?: fm.InitReq): Promise<WSDataset> {
+    return fm.fetchReq<SingleWSDatasetRequest, WSDataset>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-datasets/${req["datasetId"]}`, {...initReq, method: "DELETE"})
+  }
+}

package/management-api/dataset/v1alpha1/dataset_volume.pb.ts

@@ -0,0 +1,107 @@
+/* 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 GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+import * as HydraManagement_apiModelV1alpha1Model_weights_volume from "../../model/v1alpha1/model_weights_volume.pb"
+import * as HydraManagement_apiDatasetV1alpha1Dataset from "./dataset.pb"
+export type WSDatasetVolume = {
+  id?: string
+  datasetId?: string
+  datasetTag?: string
+  clusterName?: string
+  storageSource?: HydraManagement_apiModelV1alpha1Model_weights_volume.StorageSourceType
+  storageRef?: string
+  subPath?: string
+  mountPath?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  updateTimestamp?: GoogleProtobufTimestamp.Timestamp
+  referenced?: boolean
+  lfDatasetInfoJson?: string
+  datasetFormat?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetFormat
+  datasetUsageType?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetUsageType
+}
+
+export type CreateWSDatasetVolumeRequest = {
+  workspace?: number
+  id?: string
+  datasetId?: string
+  clusterName?: string
+  datasetTag?: string
+  storageSource?: HydraManagement_apiModelV1alpha1Model_weights_volume.StorageSourceType
+  storageRef?: string
+  subPath?: string
+  mountPath?: string
+  lfDatasetInfoJson?: string
+  datasetFormat?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetFormat
+  datasetUsageType?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetUsageType
+}
+
+export type UpdateWSDatasetVolumeRequest = {
+  workspace?: number
+  id?: string
+  datasetId?: string
+  clusterName?: string
+  datasetTag?: string
+  storageSource?: HydraManagement_apiModelV1alpha1Model_weights_volume.StorageSourceType
+  storageRef?: string
+  subPath?: string
+  mountPath?: string
+  lfDatasetInfoJson?: string
+  datasetFormat?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetFormat
+  datasetUsageType?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetUsageType
+}
+
+export type SingleWSDatasetVolumeRequest = {
+  workspace?: number
+  id?: string
+  datasetId?: string
+}
+
+export type ListWSDatasetVolumesRequest = {
+  workspace?: number
+  datasetId?: string
+  page?: HydraCommonCommon.Pagination
+  clusterName?: string
+  datasetFormat?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetFormat
+  datasetUsageType?: HydraManagement_apiDatasetV1alpha1Dataset.DatasetUsageType
+}
+
+export type ListWSDatasetVolumesResponse = {
+  items?: WSDatasetVolume[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type GetWSDatasetStorageSourceRequest = {
+  workspace?: number
+  datasetId?: string
+}
+
+export type GetWSDatasetStorageSourceResponse = {
+  sources?: {[key: string]: number}
+}
+
+export class WSDatasetVolumeManagement {
+  static CreateWSDatasetVolume(req: CreateWSDatasetVolumeRequest, initReq?: fm.InitReq): Promise<WSDatasetVolume> {
+    return fm.fetchReq<CreateWSDatasetVolumeRequest, WSDatasetVolume>(`/apis/hydra.io/v1alpha1/datasets/${req["datasetId"]}/workspaces/${req["workspace"]}/volumes`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdateWSDatasetVolume(req: UpdateWSDatasetVolumeRequest, initReq?: fm.InitReq): Promise<WSDatasetVolume> {
+    return fm.fetchReq<UpdateWSDatasetVolumeRequest, WSDatasetVolume>(`/apis/hydra.io/v1alpha1/datasets/${req["datasetId"]}/workspaces/${req["workspace"]}/volumes/${req["id"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DeleteWSDatasetVolume(req: SingleWSDatasetVolumeRequest, initReq?: fm.InitReq): Promise<WSDatasetVolume> {
+    return fm.fetchReq<SingleWSDatasetVolumeRequest, WSDatasetVolume>(`/apis/hydra.io/v1alpha1/datasets/${req["datasetId"]}/workspaces/${req["workspace"]}/volumes/${req["id"]}`, {...initReq, method: "DELETE"})
+  }
+  static GetWSDatasetVolume(req: SingleWSDatasetVolumeRequest, initReq?: fm.InitReq): Promise<WSDatasetVolume> {
+    return fm.fetchReq<SingleWSDatasetVolumeRequest, WSDatasetVolume>(`/apis/hydra.io/v1alpha1/datasets/${req["datasetId"]}/workspaces/${req["workspace"]}/volumes/${req["id"]}?${fm.renderURLSearchParams(req, ["datasetId", "workspace", "id"])}`, {...initReq, method: "GET"})
+  }
+  static ListWSDatasetVolumes(req: ListWSDatasetVolumesRequest, initReq?: fm.InitReq): Promise<ListWSDatasetVolumesResponse> {
+    return fm.fetchReq<ListWSDatasetVolumesRequest, ListWSDatasetVolumesResponse>(`/apis/hydra.io/v1alpha1/datasets/${req["datasetId"]}/workspaces/${req["workspace"]}/volumes?${fm.renderURLSearchParams(req, ["datasetId", "workspace"])}`, {...initReq, method: "GET"})
+  }
+  static GetWSDatasetStorageSource(req: GetWSDatasetStorageSourceRequest, initReq?: fm.InitReq): Promise<GetWSDatasetStorageSourceResponse> {
+    return fm.fetchReq<GetWSDatasetStorageSourceRequest, GetWSDatasetStorageSourceResponse>(`/apis/hydra.io/v1alpha1/datasets/${req["datasetId"]}/workspaces/${req["workspace"]}/volumes:storage-source?${fm.renderURLSearchParams(req, ["datasetId", "workspace"])}`, {...initReq, method: "GET"})
+  }
+}