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

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

@@ -6,6 +6,7 @@
 
 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"
 
 export enum ModelSupportFeature {
@@ -29,14 +30,6 @@ export enum PublicModelConfigRateLimitLimitedBy {
   API_KEY = "API_KEY",
 }
 
-export enum DeployTemplateGPUType {
-  GPU_TYPE_UNSPECIFIED = "GPU_TYPE_UNSPECIFIED",
-  NVIDIA_GPU = "NVIDIA_GPU",
-  NVIDIA_vGPU = "NVIDIA_vGPU",
-  NO_GPU = "NO_GPU",
-  METAX_GPU = "METAX_GPU",
-}
-
 export enum DeployTemplateInferenceRuntime {
   INFERENCE_RUNTIME_UNSPECIFIED = "INFERENCE_RUNTIME_UNSPECIFIED",
   VLLM = "VLLM",
@@ -48,6 +41,7 @@ export type ModelPrice = {
   inputPerKTokens?: string
   outputPerKTokens?: string
   perImage?: string
+  cachedPerKTokens?: string
 }
 
 export type Model = {
@@ -68,6 +62,7 @@ export type Model = {
   readme?: HydraCommonCommon.I18nName
   publicModelConfig?: PublicModelConfig
   modelDeploymentsExists?: boolean
+  visible?: string
 }
 
 export type ListModelRequest = {
@@ -101,9 +96,10 @@ export type ModelServingSpec = {
 export type DeployTemplateResourcesRequirements = {
   cpu?: number
   memory?: number
-  gpuType?: DeployTemplateGPUType
+  gpuType?: string
   gpuCount?: number
   perGpuMemory?: number
+  gpuCores?: number
 }
 
 export type DeployTemplate = {
@@ -113,6 +109,9 @@ export type DeployTemplate = {
   customDeployArgs?: string[]
   env?: EnvVar[]
   inferenceRuntime?: string
+  runtimeCommand?: string
+  templateName?: string
+  templateDescription?: string
 }
 
 export type EnvVar = {
@@ -120,6 +119,15 @@ export type EnvVar = {
   value?: string
 }
 
+export type ModelTemplate = {
+  templateId?: string
+  modelId?: string
+  workspace?: number
+  spec?: DeployTemplate
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  updateTimestamp?: GoogleProtobufTimestamp.Timestamp
+}
+
 export type ListWSModelRequest = {
   workspace?: number
   page?: HydraCommonCommon.Pagination
@@ -152,6 +160,71 @@ export type WSModel = {
   readme?: HydraCommonCommon.I18nName
   publicModelConfig?: PublicModelConfig
   modelDeploymentsExists?: boolean
+  visible?: string
+  tokenWeight?: string
+}
+
+export type CreatePrivateModelRequest = {
+  workspace?: number
+  modelAvatar?: string
+  modelName?: string
+  modelDescription?: HydraCommonCommon.I18nName
+  modelSupportFeature?: ModelSupportFeature[]
+  readme?: HydraCommonCommon.I18nName
+  servingSpec?: ModelServingSpec
+}
+
+export type UpdatePrivateModelRequest = {
+  workspace?: number
+  modelId?: string
+  modelAvatar?: string
+  modelName?: string
+  modelDescription?: HydraCommonCommon.I18nName
+  modelSupportFeature?: ModelSupportFeature[]
+  readme?: HydraCommonCommon.I18nName
+  servingSpec?: ModelServingSpec
+}
+
+export type ListPrivateModelRequest = {
+  workspace?: number
+  page?: HydraCommonCommon.Pagination
+}
+
+export type CreateModelTemplateRequest = {
+  workspace?: number
+  modelId?: string
+  spec?: DeployTemplate
+}
+
+export type GetModelTemplateRequest = {
+  workspace?: number
+  templateId?: string
+  modelId?: string
+}
+
+export type UpdateModelTemplateRequest = {
+  workspace?: number
+  templateId?: string
+  spec?: DeployTemplate
+  modelId?: string
+}
+
+export type DeleteModelTemplateRequest = {
+  workspace?: number
+  templateId?: string
+  modelId?: string
+}
+
+export type ListModelTemplatesRequest = {
+  workspace?: number
+  modelId?: string
+  inferenceRuntime?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListModelTemplatesResponse = {
+  items?: ModelTemplate[]
+  page?: HydraCommonCommon.Pagination
 }
 
 export class ModelManagement {
@@ -169,4 +242,36 @@ export class WSModelManagement {
   static ListWSModels(req: ListWSModelRequest, initReq?: fm.InitReq): Promise<ListWSModelResponse> {
     return fm.fetchReq<ListWSModelRequest, ListWSModelResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/models?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
   }
+  static ListPrivateModels(req: ListPrivateModelRequest, initReq?: fm.InitReq): Promise<ListWSModelResponse> {
+    return fm.fetchReq<ListPrivateModelRequest, ListWSModelResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-models?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static GetPrivateModel(req: SingleWSModelRequest, initReq?: fm.InitReq): Promise<WSModel> {
+    return fm.fetchReq<SingleWSModelRequest, WSModel>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-models/${req["modelId"]}?${fm.renderURLSearchParams(req, ["workspace", "modelId"])}`, {...initReq, method: "GET"})
+  }
+  static CreatePrivateModel(req: CreatePrivateModelRequest, initReq?: fm.InitReq): Promise<WSModel> {
+    return fm.fetchReq<CreatePrivateModelRequest, WSModel>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-models`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdatePrivateModel(req: UpdatePrivateModelRequest, initReq?: fm.InitReq): Promise<WSModel> {
+    return fm.fetchReq<UpdatePrivateModelRequest, WSModel>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-models/${req["modelId"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DeletePrivateModel(req: SingleWSModelRequest, initReq?: fm.InitReq): Promise<WSModel> {
+    return fm.fetchReq<SingleWSModelRequest, WSModel>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/private-models/${req["modelId"]}`, {...initReq, method: "DELETE"})
+  }
+}
+export class WSModelTemplateManagement {
+  static CreateWSModelTemplate(req: CreateModelTemplateRequest, initReq?: fm.InitReq): Promise<ModelTemplate> {
+    return fm.fetchReq<CreateModelTemplateRequest, ModelTemplate>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/models/${req["modelId"]}/model-templates`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static GetWSModelTemplate(req: GetModelTemplateRequest, initReq?: fm.InitReq): Promise<ModelTemplate> {
+    return fm.fetchReq<GetModelTemplateRequest, ModelTemplate>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/models/${req["modelId"]}/model-templates/${req["templateId"]}?${fm.renderURLSearchParams(req, ["workspace", "modelId", "templateId"])}`, {...initReq, method: "GET"})
+  }
+  static UpdateWSModelTemplate(req: UpdateModelTemplateRequest, initReq?: fm.InitReq): Promise<ModelTemplate> {
+    return fm.fetchReq<UpdateModelTemplateRequest, ModelTemplate>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/models/${req["modelId"]}/model-templates/${req["templateId"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DeleteWSModelTemplate(req: DeleteModelTemplateRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<DeleteModelTemplateRequest, GoogleProtobufEmpty.Empty>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/models/${req["modelId"]}/model-templates/${req["templateId"]}`, {...initReq, method: "DELETE"})
+  }
+  static ListWSModelTemplates(req: ListModelTemplatesRequest, initReq?: fm.InitReq): Promise<ListModelTemplatesResponse> {
+    return fm.fetchReq<ListModelTemplatesRequest, ListModelTemplatesResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/models/${req["modelId"]}/model-templates?${fm.renderURLSearchParams(req, ["workspace", "modelId"])}`, {...initReq, method: "GET"})
+  }
 }

package/management-api/model/v1alpha1/model_weights_volume.pb.ts

@@ -0,0 +1,101 @@
+/* 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 StorageSourceType {
+  STORAGE_SOURCE_TYPE_UNSPECIFIED = "STORAGE_SOURCE_TYPE_UNSPECIFIED",
+  FILES_STORAGE = "FILES_STORAGE",
+  PVC_STORAGE = "PVC_STORAGE",
+}
+
+export type WSModelWeightsVolume = {
+  id?: string
+  modelId?: string
+  modelTag?: string
+  clusterName?: string
+  storageSource?: StorageSourceType
+  storageRef?: string
+  subPath?: string
+  mountPath?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  updateTimestamp?: GoogleProtobufTimestamp.Timestamp
+  referenced?: boolean
+}
+
+export type CreateWSModelWeightsVolumeRequest = {
+  workspace?: number
+  id?: string
+  modelId?: string
+  clusterName?: string
+  modelTag?: string
+  storageSource?: StorageSourceType
+  storageRef?: string
+  subPath?: string
+  mountPath?: string
+}
+
+export type UpdateWSModelWeightsVolumeRequest = {
+  workspace?: number
+  id?: string
+  modelId?: string
+  clusterName?: string
+  modelTag?: string
+  storageSource?: StorageSourceType
+  storageRef?: string
+  subPath?: string
+  mountPath?: string
+}
+
+export type SingleWSModelWeightsVolumeRequest = {
+  workspace?: number
+  id?: string
+  modelId?: string
+}
+
+export type ListWSModelWeightsVolumesRequest = {
+  workspace?: number
+  modelId?: string
+  page?: HydraCommonCommon.Pagination
+  clusterName?: string
+}
+
+export type ListWSModelWeightsVolumesResponse = {
+  items?: WSModelWeightsVolume[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type GetWSStorageSourceRequest = {
+  workspace?: number
+  modelId?: string
+}
+
+export type GetWSStorageSourceResponse = {
+  sources?: {[key: string]: number}
+}
+
+export class WSModelWeightsVolumeManagement {
+  static CreateWSModelWeightsVolume(req: CreateWSModelWeightsVolumeRequest, initReq?: fm.InitReq): Promise<WSModelWeightsVolume> {
+    return fm.fetchReq<CreateWSModelWeightsVolumeRequest, WSModelWeightsVolume>(`/apis/hydra.io/v1alpha1/models/${req["modelId"]}/workspaces/${req["workspace"]}/weights`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdateWSModelWeightsVolume(req: UpdateWSModelWeightsVolumeRequest, initReq?: fm.InitReq): Promise<WSModelWeightsVolume> {
+    return fm.fetchReq<UpdateWSModelWeightsVolumeRequest, WSModelWeightsVolume>(`/apis/hydra.io/v1alpha1/models/${req["modelId"]}/workspaces/${req["workspace"]}/weights/${req["id"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DeleteWSModelWeightsVolume(req: SingleWSModelWeightsVolumeRequest, initReq?: fm.InitReq): Promise<WSModelWeightsVolume> {
+    return fm.fetchReq<SingleWSModelWeightsVolumeRequest, WSModelWeightsVolume>(`/apis/hydra.io/v1alpha1/models/${req["modelId"]}/workspaces/${req["workspace"]}/weights/${req["id"]}`, {...initReq, method: "DELETE"})
+  }
+  static GetWSModelWeightsVolume(req: SingleWSModelWeightsVolumeRequest, initReq?: fm.InitReq): Promise<WSModelWeightsVolume> {
+    return fm.fetchReq<SingleWSModelWeightsVolumeRequest, WSModelWeightsVolume>(`/apis/hydra.io/v1alpha1/models/${req["modelId"]}/workspaces/${req["workspace"]}/weights/${req["id"]}?${fm.renderURLSearchParams(req, ["modelId", "workspace", "id"])}`, {...initReq, method: "GET"})
+  }
+  static ListWSModelWeightsVolumes(req: ListWSModelWeightsVolumesRequest, initReq?: fm.InitReq): Promise<ListWSModelWeightsVolumesResponse> {
+    return fm.fetchReq<ListWSModelWeightsVolumesRequest, ListWSModelWeightsVolumesResponse>(`/apis/hydra.io/v1alpha1/models/${req["modelId"]}/workspaces/${req["workspace"]}/weights?${fm.renderURLSearchParams(req, ["modelId", "workspace"])}`, {...initReq, method: "GET"})
+  }
+  static GetWSStorageSource(req: GetWSStorageSourceRequest, initReq?: fm.InitReq): Promise<GetWSStorageSourceResponse> {
+    return fm.fetchReq<GetWSStorageSourceRequest, GetWSStorageSourceResponse>(`/apis/hydra.io/v1alpha1/models/${req["modelId"]}/workspaces/${req["workspace"]}/weights:storage-source?${fm.renderURLSearchParams(req, ["modelId", "workspace"])}`, {...initReq, method: "GET"})
+  }
+}

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

@@ -8,12 +8,28 @@ 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 from "../../model/v1alpha1/model.pb"
+import * as HydraManagement_apiModelV1alpha1Model_weights_volume from "../../model/v1alpha1/model_weights_volume.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 PaymentMethod {
   PAYMENT_METHOD_UNSPECIFIED = "PAYMENT_METHOD_UNSPECIFIED",
   PAY_AS_YOU_GO = "PAY_AS_YOU_GO",
 }
 
+export enum PlacementPolicy {
+  PLACEMENT_POLICY_UNSPECIFIED = "PLACEMENT_POLICY_UNSPECIFIED",
+  BALANCED = "BALANCED",
+  GROUPED = "GROUPED",
+}
+
 export enum ModelServingStatus {
   STATUS_UNSPECIFIED = "STATUS_UNSPECIFIED",
   DEPLOYING = "DEPLOYING",
@@ -24,6 +40,12 @@ export enum ModelServingStatus {
   STOPPED = "STOPPED",
 }
 
+export enum ModelVisible {
+  MODEL_VISIBLE_UNSPECIFIED = "MODEL_VISIBLE_UNSPECIFIED",
+  MODEL_VISIBLE_PUBLIC = "MODEL_VISIBLE_PUBLIC",
+  MODEL_VISIBLE_PRIVATE = "MODEL_VISIBLE_PRIVATE",
+}
+
 export enum DeployDetectConditionType {
   DEPLOY_DETECT_CONDITION_TYPE_UNSPECIFIED = "DEPLOY_DETECT_CONDITION_TYPE_UNSPECIFIED",
   CLUSTER_RESOURCE_AVAILABLE = "CLUSTER_RESOURCE_AVAILABLE",
@@ -41,6 +63,53 @@ export enum WSModelServingActionRequestAction {
   STOP = "STOP",
 }
 
+export type SchedulingConfig = {
+  queueName?: string
+  priorityClass?: string
+  placementPolicy?: PlacementPolicy
+}
+
+export type PreflightConfig = {
+  enabled?: boolean
+  nodeCheckIbHcas?: string[]
+  nodeCheckBusbwThresholdGbps?: string
+}
+
+export type WeightVolumeConfig = {
+  modelId?: string
+  modelTag?: string
+  storageSource?: HydraManagement_apiModelV1alpha1Model_weights_volume.StorageSourceType
+  storageRef?: string
+  subPath?: string
+  mountPath?: string
+}
+
+
+/* hydra modified */ export type BaseResourceConfig = {
+  cpu?: number
+  memory?: number
+  gpuType?: string
+  gpuCount?: number
+  perGpuMemory?: number
+}
+
+export type ResourceConfig = BaseResourceConfig
+  & OneOf<{ gpuCores: number }>
+
+export type EnvVar = {
+  name?: string
+  value?: string
+}
+
+export type RuntimeConfig = {
+  runtimeType?: string
+  runtimeImage?: string
+  versionRequired?: string
+  imagePullSecretName?: string[]
+  runtimeCommand?: string
+  env?: EnvVar[]
+}
+
 export type CreateModelServingRequest = {
   name?: string
   modelId?: string
@@ -48,17 +117,30 @@ export type CreateModelServingRequest = {
   replicas?: number
   skuId?: string
   paymentMethods?: PaymentMethod
+  enableMetrics?: boolean
 }
 
-export type CreateWSModelServingRequest = {
+
+/* hydra modified */ export type BaseCreateWSModelServingRequest = {
   name?: string
   modelId?: string
   workspace?: number
   cluster?: string
   namespace?: string
   replicas?: number
+  nodeSize?: number
+  weightVolumeId?: string
+  resourceConfig?: ResourceConfig
+  runtimeConfig?: RuntimeConfig
+  tokenWeight?: string
+  enableMetrics?: boolean
 }
 
+export type CreateWSModelServingRequest = BaseCreateWSModelServingRequest
+  & OneOf<{ weightVolumeConfig: WeightVolumeConfig }>
+  & OneOf<{ schedulingConfig: SchedulingConfig }>
+  & OneOf<{ preflight: PreflightConfig }>
+
 export type ModelServing = {
   id?: string
   name?: string
@@ -81,13 +163,15 @@ export type ModelServing = {
   modelSupportFeature?: HydraManagement_apiModelV1alpha1Model.ModelSupportFeature[]
 }
 
-export type WSModelServing = {
+
+/* hydra modified */ export type BaseWSModelServing = {
   id?: string
   name?: string
   modelId?: string
   modelName?: string
   cluster?: string
   replicas?: number
+  nodeSize?: number
   status?: ModelServingStatus
   creationTimestamp?: GoogleProtobufTimestamp.Timestamp
   accessModelName?: string
@@ -95,8 +179,17 @@ export type WSModelServing = {
   address?: string
   modelAvatar?: string
   modelSupportFeature?: HydraManagement_apiModelV1alpha1Model.ModelSupportFeature[]
+  resourceConfig?: ResourceConfig
+  runtimeConfig?: RuntimeConfig
+  weightVolumeConfig?: WeightVolumeConfig
+  modelVisible?: ModelVisible
+  tokenWeight?: string
+  preflight?: PreflightConfig
 }
 
+export type WSModelServing = BaseWSModelServing
+  & OneOf<{ schedulingConfig: SchedulingConfig }>
+
 export type ListModelServingRequest = {
   page?: HydraCommonCommon.Pagination
 }
@@ -120,8 +213,6 @@ export type ListWSModelServingResponse = {
 
 export type GetWSModelServingRequest = {
   workspace?: number
-  cluster?: string
-  namespace?: string
   id?: string
 }
 
@@ -166,13 +257,22 @@ export type WSModelServingActionRequest = {
   action?: WSModelServingActionRequestAction
 }
 
-export type WSModelServingDeployDetectionRequest = {
+
+/* hydra modified */ export type BaseWSModelServingDeployDetectionRequest = {
   workspace?: number
   modelId?: string
   cluster?: string
   namespace?: string
+  nodeSize?: number
+  weightVolumeId?: string
+  resourceConfig?: ResourceConfig
+  runtimeConfig?: RuntimeConfig
 }
 
+export type WSModelServingDeployDetectionRequest = BaseWSModelServingDeployDetectionRequest
+  & OneOf<{ weightVolumeConfig: WeightVolumeConfig }>
+  & OneOf<{ schedulingConfig: SchedulingConfig }>
+
 export type ModelServingDeployDetectionResponse = {
   ready?: boolean
   conditions?: DeployDetectCondition[]

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

@@ -0,0 +1,20 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export enum RequestModelType {
+  REQUEST_MODEL_TYPE_UNSPECIFIED = "REQUEST_MODEL_TYPE_UNSPECIFIED",
+  TEXT_GENERATION = "TEXT_GENERATION",
+  VIDEO_TO_TEXT = "VIDEO_TO_TEXT",
+  TEXT_TO_VIDEO = "TEXT_TO_VIDEO",
+  IMAGE_TO_IMAGE = "IMAGE_TO_IMAGE",
+  IMAGE_TO_TEXT = "IMAGE_TO_TEXT",
+  TEXT_TO_IMAGE = "TEXT_TO_IMAGE",
+  EMBEDDING = "EMBEDDING",
+  RERANK_MODEL = "RERANK_MODEL",
+  AUDIO_TO_AUDIO = "AUDIO_TO_AUDIO",
+  AUDIO_TO_TEXT = "AUDIO_TO_TEXT",
+  TEXT_TO_AUDIO = "TEXT_TO_AUDIO",
+}

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

@@ -0,0 +1,121 @@
+/* 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 QueueType {
+  QUEUE_TYPE_UNSPECIFIED = "QUEUE_TYPE_UNSPECIFIED",
+  KUEUE = "KUEUE",
+}
+
+export enum QueuePhase {
+  QUEUE_PHASE_UNSPECIFIED = "QUEUE_PHASE_UNSPECIFIED",
+  READY = "READY",
+}
+
+export enum QueueStrategy {
+  QUEUE_STRATEGY_UNSPECIFIED = "QUEUE_STRATEGY_UNSPECIFIED",
+  STRICT_FIFO = "STRICT_FIFO",
+  BEST_EFFORT_FIFO = "BEST_EFFORT_FIFO",
+}
+
+export enum QueuePreemptionWithinClusterQueuePolicy {
+  QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_UNSPECIFIED = "QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_UNSPECIFIED",
+  QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_NEVER = "QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_NEVER",
+  QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_LOWER_PRIORITY = "QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_LOWER_PRIORITY",
+  QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_LOWER_OR_NEWER_EQUALPRIORITY = "QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_LOWER_OR_NEWER_EQUALPRIORITY",
+  QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_ANY = "QUEUE_PREEMPTION_WITHIN_CLUSTER_QUEUE_POLICY_ANY",
+}
+
+export type CheckQueueRequest = {
+  type?: QueueType
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type CheckQueueResponse = {
+  type?: QueueType
+  exist?: boolean
+}
+
+export type CreateLocalQueueRequest = {
+  type?: QueueType
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type QueueStatus = {
+  phase?: QueuePhase
+}
+
+export type CreateLocalQueueResponse = {
+  type?: QueueType
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  status?: QueueStatus
+}
+
+export type ListQueueRequest = {
+  workspace?: number
+  cluster?: string
+  type?: QueueType
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListQueueResponse = {
+  items?: Queue[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type QueueResource = {
+  name?: string
+  value?: string
+  borrowingLimit?: string
+}
+
+export type QueueFlavor = {
+  name?: string
+  resources?: QueueResource[]
+  resourcesAvailable?: QueueResource[]
+  nodes?: HydraCommonCommon.Node[]
+}
+
+export type Queue = {
+  type?: QueueType
+  cluster?: string
+  name?: string
+  workspace?: number
+  description?: string
+  resources?: QueueResource[]
+  resourcesAvailable?: QueueResource[]
+  labels?: {[key: string]: string}
+  annotations?: {[key: string]: string}
+  status?: QueueStatus
+  strategy?: QueueStrategy
+  workspaceAlias?: string
+  preemptionWithinClusterQueue?: QueuePreemptionWithinClusterQueuePolicy
+  flavors?: QueueFlavor[]
+  tasEnabled?: boolean
+}
+
+export class QueueManagement {
+  static CheckQueue(req: CheckQueueRequest, initReq?: fm.InitReq): Promise<CheckQueueResponse> {
+    return fm.fetchReq<CheckQueueRequest, CheckQueueResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/queues/${req["name"]}/capacites?${fm.renderURLSearchParams(req, ["workspace", "cluster", "name"])}`, {...initReq, method: "GET"})
+  }
+  static CreateLocalQueue(req: CreateLocalQueueRequest, initReq?: fm.InitReq): Promise<CreateLocalQueueResponse> {
+    return fm.fetchReq<CreateLocalQueueRequest, CreateLocalQueueResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/localqueues`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static ListQueues(req: ListQueueRequest, initReq?: fm.InitReq): Promise<ListQueueResponse> {
+    return fm.fetchReq<ListQueueRequest, ListQueueResponse>(`/apis/hydra.io/v1alpha1/queues?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}