@daocloud-proto/hydra 0.0.0-dev-65873840

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

@@ -0,0 +1,68 @@
+/* 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 type Provider = {
+  providerId?: string
+  providerName?: HydraCommonCommon.I18nName
+  providerAvatar?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+}
+
+export type ListProviderRequest = {
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListProviderResponse = {
+  items?: Provider[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type SingleProviderRequest = {
+  id?: string
+}
+
+export type ListWSProviderRequest = {
+  page?: HydraCommonCommon.Pagination
+  workspace?: number
+}
+
+export type ListWSProviderResponse = {
+  items?: WSProvider[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type WSProvider = {
+  providerId?: string
+  providerName?: HydraCommonCommon.I18nName
+  providerAvatar?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  workspace?: number
+}
+
+export type SingleWSProviderRequest = {
+  id?: string
+  workspace?: number
+}
+
+export class ProviderManagement {
+  static GetProvider(req: SingleProviderRequest, initReq?: fm.InitReq): Promise<Provider> {
+    return fm.fetchReq<SingleProviderRequest, Provider>(`/apis/hydra.io/v1alpha1/providers/${req["id"]}?${fm.renderURLSearchParams(req, ["id"])}`, {...initReq, method: "GET"})
+  }
+  static ListProvider(req: ListProviderRequest, initReq?: fm.InitReq): Promise<ListProviderResponse> {
+    return fm.fetchReq<ListProviderRequest, ListProviderResponse>(`/apis/hydra.io/v1alpha1/providers?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}
+export class WSProviderManagement {
+  static GetWSProvider(req: SingleWSProviderRequest, initReq?: fm.InitReq): Promise<WSProvider> {
+    return fm.fetchReq<SingleWSProviderRequest, WSProvider>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/providers/${req["id"]}?${fm.renderURLSearchParams(req, ["workspace", "id"])}`, {...initReq, method: "GET"})
+  }
+  static ListWSProvider(req: ListWSProviderRequest, initReq?: fm.InitReq): Promise<ListWSProviderResponse> {
+    return fm.fetchReq<ListWSProviderRequest, ListWSProviderResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/providers?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+}

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

@@ -0,0 +1,317 @@
+/* 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 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",
+  FAILED = "FAILED",
+  RUNNING = "RUNNING",
+  SCALING = "SCALING",
+  DELETING = "DELETING",
+  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",
+  MODEL_IMAGE_DOWNLOADED = "MODEL_IMAGE_DOWNLOADED",
+}
+
+export enum ModelServingActionRequestAction {
+  MODEL_SERVING_ACTION_UNSPECIFIED = "MODEL_SERVING_ACTION_UNSPECIFIED",
+  START = "START",
+}
+
+export enum WSModelServingActionRequestAction {
+  MODEL_SERVING_ACTION_UNSPECIFIED = "MODEL_SERVING_ACTION_UNSPECIFIED",
+  START = "START",
+  STOP = "STOP",
+}
+
+export type SchedulingConfig = {
+  queueName?: string
+  priorityClass?: string
+  placementPolicy?: PlacementPolicy
+}
+
+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
+  region?: string
+  replicas?: number
+  skuId?: string
+  paymentMethods?: PaymentMethod
+}
+
+
+/* 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
+}
+
+export type CreateWSModelServingRequest = BaseCreateWSModelServingRequest
+  & OneOf<{ weightVolumeConfig: WeightVolumeConfig }>
+  & OneOf<{ schedulingConfig: SchedulingConfig }>
+
+export type ModelServing = {
+  id?: string
+  name?: string
+  modelId?: string
+  modelName?: string
+  region?: string
+  replicas?: number
+  skuId?: string
+  paymentMethods?: PaymentMethod
+  status?: ModelServingStatus
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  outBill?: boolean
+  accessModelName?: string
+  namespace?: string
+  stop?: string[]
+  stopTokenIds?: number[]
+  address?: string
+  modelAvatar?: string
+  regionName?: HydraCommonCommon.I18nName
+  modelSupportFeature?: HydraManagement_apiModelV1alpha1Model.ModelSupportFeature[]
+}
+
+
+/* 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
+  namespace?: string
+  address?: string
+  modelAvatar?: string
+  modelSupportFeature?: HydraManagement_apiModelV1alpha1Model.ModelSupportFeature[]
+  resourceConfig?: ResourceConfig
+  runtimeConfig?: RuntimeConfig
+  weightVolumeConfig?: WeightVolumeConfig
+  modelVisible?: ModelVisible
+}
+
+export type WSModelServing = BaseWSModelServing
+  & OneOf<{ schedulingConfig: SchedulingConfig }>
+
+export type ListModelServingRequest = {
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListModelServingResponse = {
+  items?: ModelServing[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListWSModelServingRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListWSModelServingResponse = {
+  items?: WSModelServing[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type GetWSModelServingRequest = {
+  workspace?: number
+  id?: string
+}
+
+export type GetModelServingRequest = {
+  id?: string
+}
+
+export type DeleteModelServingRequest = {
+  id?: string
+}
+
+export type DeleteWSModelServingRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  id?: string
+}
+
+export type UpdateModelServingReplicasRequest = {
+  id?: string
+  replicas?: number
+}
+
+export type UpdateWSModelServingReplicasRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  id?: string
+  replicas?: number
+}
+
+export type ModelServingActionRequest = {
+  id?: string
+  action?: ModelServingActionRequestAction
+}
+
+export type WSModelServingActionRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  id?: string
+  action?: WSModelServingActionRequestAction
+}
+
+
+/* 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[]
+}
+
+export type DeployDetectCondition = {
+  type?: DeployDetectConditionType
+  ready?: boolean
+  message?: string
+}
+
+export class ModelServingManagement {
+  static CreateModelServing(req: CreateModelServingRequest, initReq?: fm.InitReq): Promise<ModelServing> {
+    return fm.fetchReq<CreateModelServingRequest, ModelServing>(`/apis/hydra.io/v1alpha1/model-serving`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static ListModelServing(req: ListModelServingRequest, initReq?: fm.InitReq): Promise<ListModelServingResponse> {
+    return fm.fetchReq<ListModelServingRequest, ListModelServingResponse>(`/apis/hydra.io/v1alpha1/model-serving?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static GetModelServing(req: GetModelServingRequest, initReq?: fm.InitReq): Promise<ModelServing> {
+    return fm.fetchReq<GetModelServingRequest, ModelServing>(`/apis/hydra.io/v1alpha1/model-serving/${req["id"]}?${fm.renderURLSearchParams(req, ["id"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteModelServing(req: DeleteModelServingRequest, initReq?: fm.InitReq): Promise<ModelServing> {
+    return fm.fetchReq<DeleteModelServingRequest, ModelServing>(`/apis/hydra.io/v1alpha1/model-serving/${req["id"]}`, {...initReq, method: "DELETE", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdateModelServingReplicas(req: UpdateModelServingReplicasRequest, initReq?: fm.InitReq): Promise<ModelServing> {
+    return fm.fetchReq<UpdateModelServingReplicasRequest, ModelServing>(`/apis/hydra.io/v1alpha1/model-serving/${req["id"]}/replicas`, {...initReq, method: "PATCH", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DoModelServingAction(req: ModelServingActionRequest, initReq?: fm.InitReq): Promise<ModelServing> {
+    return fm.fetchReq<ModelServingActionRequest, ModelServing>(`/apis/hydra.io/v1alpha1/model-serving/${req["id"]}/actions`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+}
+export class WSModelServingManagement {
+  static DetectWSModelServing(req: WSModelServingDeployDetectionRequest, initReq?: fm.InitReq): Promise<ModelServingDeployDetectionResponse> {
+    return fm.fetchReq<WSModelServingDeployDetectionRequest, ModelServingDeployDetectionResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/model-serving/detect`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static CreateWSModelServing(req: CreateWSModelServingRequest, initReq?: fm.InitReq): Promise<WSModelServing> {
+    return fm.fetchReq<CreateWSModelServingRequest, WSModelServing>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/model-serving`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static ListWSModelServing(req: ListWSModelServingRequest, initReq?: fm.InitReq): Promise<ListWSModelServingResponse> {
+    return fm.fetchReq<ListWSModelServingRequest, ListWSModelServingResponse>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/model-serving?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+  }
+  static GetWSModelServing(req: GetWSModelServingRequest, initReq?: fm.InitReq): Promise<WSModelServing> {
+    return fm.fetchReq<GetWSModelServingRequest, WSModelServing>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/model-serving/${req["id"]}?${fm.renderURLSearchParams(req, ["workspace", "id"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteWSModelServing(req: DeleteWSModelServingRequest, initReq?: fm.InitReq): Promise<WSModelServing> {
+    return fm.fetchReq<DeleteWSModelServingRequest, WSModelServing>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/model-serving/${req["id"]}`, {...initReq, method: "DELETE", body: JSON.stringify(req, fm.replacer)})
+  }
+  static UpdateWSModelServingReplicas(req: UpdateWSModelServingReplicasRequest, initReq?: fm.InitReq): Promise<WSModelServing> {
+    return fm.fetchReq<UpdateWSModelServingReplicasRequest, WSModelServing>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/model-serving/${req["id"]}/replicas`, {...initReq, method: "PATCH", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DoModelWSServingAction(req: WSModelServingActionRequest, initReq?: fm.InitReq): Promise<WSModelServing> {
+    return fm.fetchReq<WSModelServingActionRequest, WSModelServing>(`/apis/hydra.io/v1alpha1/workspaces/${req["workspace"]}/model-serving/${req["id"]}/actions`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+}

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

@@ -0,0 +1,77 @@
+/* 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 SKUPaymentMethod {
+  PAYMENT_METHOD_UNSPECIFIED = "PAYMENT_METHOD_UNSPECIFIED",
+  PAY_AS_YOU_GO = "PAY_AS_YOU_GO",
+}
+
+export enum SKUPriceCurrency {
+  PRICE_UNIT_UNSPECIFIED = "PRICE_UNIT_UNSPECIFIED",
+  CNY = "CNY",
+  USD = "USD",
+}
+
+export enum ListSKURequestResourceType {
+  RESOURCE_TYPE_UNSPECIFIED = "RESOURCE_TYPE_UNSPECIFIED",
+  MODEL = "MODEL",
+}
+
+export type Region = {
+  region?: string
+  name?: HydraCommonCommon.I18nName
+  baseUrl?: string
+}
+
+export type ListRegionRequest = {
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListRegionResponse = {
+  items?: Region[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export type GetRegionRequest = {
+  region?: string
+}
+
+export type SKU = {
+  id?: string
+  description?: string
+  region?: string
+  paymentMethod?: SKUPaymentMethod
+  pricePerUnit?: string
+  priceCurrency?: SKUPriceCurrency
+  available?: boolean
+}
+
+export type ListSKURequest = {
+  region?: string
+  resourceType?: ListSKURequestResourceType
+  resourceId?: string
+  page?: HydraCommonCommon.Pagination
+}
+
+export type ListSKUResponse = {
+  items?: SKU[]
+  page?: HydraCommonCommon.Pagination
+}
+
+export class SKUManagement {
+  static ListRegions(req: ListRegionRequest, initReq?: fm.InitReq): Promise<ListRegionResponse> {
+    return fm.fetchReq<ListRegionRequest, ListRegionResponse>(`/apis/hydra.io/v1alpha1/regions?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static GetRegion(req: GetRegionRequest, initReq?: fm.InitReq): Promise<Region> {
+    return fm.fetchReq<GetRegionRequest, Region>(`/apis/hydra.io/v1alpha1/regions/${req["region"]}?${fm.renderURLSearchParams(req, ["region"])}`, {...initReq, method: "GET"})
+  }
+  static ListSKUs(req: ListSKURequest, initReq?: fm.InitReq): Promise<ListSKUResponse> {
+    return fm.fetchReq<ListSKURequest, ListSKUResponse>(`/apis/hydra.io/v1alpha1/skus?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}

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"})
+  }
+}