@daocloud-proto/kangaroo 0.1.1-10

package/fetch.pb.ts

@@ -0,0 +1,232 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export interface InitReq extends RequestInit {
+  pathPrefix?: string
+}
+
+export function fetchReq<I, O>(path: string, init?: InitReq): Promise<O> {
+  const {pathPrefix, ...req} = init || {}
+
+  const url = pathPrefix ? `${pathPrefix}${path}` : path
+
+  return fetch(url, req).then(r => r.json().then((body: O) => {
+    if (!r.ok) { throw body; }
+    return body;
+  })) as Promise<O>
+}
+
+// NotifyStreamEntityArrival is a callback that will be called on streaming entity arrival
+export type NotifyStreamEntityArrival<T> = (resp: T) => void
+
+/**
+ * fetchStreamingRequest is able to handle grpc-gateway server side streaming call
+ * it takes NotifyStreamEntityArrival that lets users respond to entity arrival during the call
+ * all entities will be returned as an array after the call finishes.
+ **/
+export async function fetchStreamingRequest<S, R>(path: string, callback?: NotifyStreamEntityArrival<R>, init?: InitReq) {
+  const {pathPrefix, ...req} = init || {}
+  const url = pathPrefix ?`${pathPrefix}${path}` : path
+  const result = await fetch(url, req)
+  // needs to use the .ok to check the status of HTTP status code
+  // http other than 200 will not throw an error, instead the .ok will become false.
+  // see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#
+  if (!result.ok) {
+    const resp = await result.json()
+    const errMsg = resp.error && resp.error.message ? resp.error.message : ""
+    throw new Error(errMsg)
+  }
+
+  if (!result.body) {
+    throw new Error("response doesnt have a body")
+  }
+
+  await result.body
+    .pipeThrough(new TextDecoderStream())
+    .pipeThrough<R>(getNewLineDelimitedJSONDecodingStream<R>())
+    .pipeTo(getNotifyEntityArrivalSink((e: R) => {
+      if (callback) {
+        callback(e)
+      }
+    }))
+
+  // wait for the streaming to finish and return the success respond
+  return
+}
+
+/**
+ * JSONStringStreamController represents the transform controller that's able to transform the incoming
+ * new line delimited json content stream into entities and able to push the entity to the down stream
+ */
+interface JSONStringStreamController<T> extends TransformStreamDefaultController {
+  buf?: string
+  pos?: number
+  enqueue: (s: T) => void
+}
+
+/**
+ * getNewLineDelimitedJSONDecodingStream returns a TransformStream that's able to handle new line delimited json stream content into parsed entities
+ */
+function getNewLineDelimitedJSONDecodingStream<T>(): TransformStream<string, T> {
+  return new TransformStream({
+    start(controller: JSONStringStreamController<T>) {
+      controller.buf = ''
+      controller.pos = 0
+    },
+
+    transform(chunk: string, controller: JSONStringStreamController<T>) {
+      if (controller.buf === undefined) {
+        controller.buf = ''
+      }
+      if (controller.pos === undefined) {
+        controller.pos = 0
+      }
+      controller.buf += chunk
+      while (controller.pos < controller.buf.length) {
+        if (controller.buf[controller.pos] === '\n') {
+          const line = controller.buf.substring(0, controller.pos)
+          const response = JSON.parse(line)
+          controller.enqueue(response.result)
+          controller.buf = controller.buf.substring(controller.pos + 1)
+          controller.pos = 0
+        } else {
+          ++controller.pos
+        }
+      }
+    }
+  })
+
+}
+
+/**
+ * getNotifyEntityArrivalSink takes the NotifyStreamEntityArrival callback and return
+ * a sink that will call the callback on entity arrival
+ * @param notifyCallback
+ */
+function getNotifyEntityArrivalSink<T>(notifyCallback: NotifyStreamEntityArrival<T>) {
+  return new WritableStream<T>({
+    write(entity: T) {
+      notifyCallback(entity)
+    }
+  })
+}
+
+type Primitive = string | boolean | number;
+type RequestPayload = Record<string, unknown>;
+type FlattenedRequestPayload = Record<string, Primitive | Array<Primitive>>;
+
+/**
+ * Checks if given value is a plain object
+ * Logic copied and adapted from below source: 
+ * https://github.com/char0n/ramda-adjunct/blob/master/src/isPlainObj.js
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPlainObject(value: unknown): boolean {
+  const isObject =
+    Object.prototype.toString.call(value).slice(8, -1) === "Object";
+  const isObjLike = value !== null && isObject;
+
+  if (!isObjLike || !isObject) {
+    return false;
+  }
+
+  const proto = Object.getPrototypeOf(value);
+
+  const hasObjectConstructor =
+    typeof proto === "object" &&
+    proto.constructor === Object.prototype.constructor;
+
+  return hasObjectConstructor;
+}
+
+/**
+ * Checks if given value is of a primitive type
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPrimitive(value: unknown): boolean {
+  return ["string", "number", "boolean"].some(t => typeof value === t);
+}
+
+/**
+ * Checks if given primitive is zero-value
+ * @param  {Primitive} value
+ * @return {boolean}
+ */
+function isZeroValuePrimitive(value: Primitive): boolean {
+  return value === false || value === 0 || value === "";
+}
+
+/**
+ * Flattens a deeply nested request payload and returns an object
+ * with only primitive values and non-empty array of primitive values
+ * as per https://github.com/googleapis/googleapis/blob/master/google/api/http.proto
+ * @param  {RequestPayload} requestPayload
+ * @param  {String} path
+ * @return {FlattenedRequestPayload>}
+ */
+function flattenRequestPayload<T extends RequestPayload>(
+  requestPayload: T,
+  path: string = ""
+): FlattenedRequestPayload {
+  return Object.keys(requestPayload).reduce(
+    (acc: T, key: string): T => {
+      const value = requestPayload[key];
+      const newPath = path ? [path, key].join(".") : key;
+
+      const isNonEmptyPrimitiveArray =
+        Array.isArray(value) &&
+        value.every(v => isPrimitive(v)) &&
+        value.length > 0;
+
+      const isNonZeroValuePrimitive =
+        isPrimitive(value) && !isZeroValuePrimitive(value as Primitive);
+
+      let objectToMerge = {};
+
+      if (isPlainObject(value)) {
+        objectToMerge = flattenRequestPayload(value as RequestPayload, newPath);
+      } else if (isNonZeroValuePrimitive || isNonEmptyPrimitiveArray) {
+        objectToMerge = { [newPath]: value };
+      }
+
+      return { ...acc, ...objectToMerge };
+    },
+    {} as T
+  ) as FlattenedRequestPayload;
+}
+
+/**
+ * Renders a deeply nested request payload into a string of URL search
+ * parameters by first flattening the request payload and then removing keys
+ * which are already present in the URL path.
+ * @param  {RequestPayload} requestPayload
+ * @param  {string[]} urlPathParams
+ * @return {string}
+ */
+export function renderURLSearchParams<T extends RequestPayload>(
+  requestPayload: T,
+  urlPathParams: string[] = []
+): string {
+  const flattenedRequestPayload = flattenRequestPayload(requestPayload);
+
+  const urlSearchParams = Object.keys(flattenedRequestPayload).reduce(
+    (acc: string[][], key: string): string[][] => {
+      // key should not be present in the url path as a parameter
+      const value = flattenedRequestPayload[key];
+      if (urlPathParams.find(f => f === key)) {
+        return acc;
+      }
+      return Array.isArray(value)
+        ? [...acc, ...value.map(m => [key, m.toString()])]
+        : (acc = [...acc, [key, value.toString()]]);
+    },
+    [] as string[][]
+  );
+
+  return new URLSearchParams(urlSearchParams).toString();
+}

package/google/api/annotations.pb.ts

@@ -0,0 +1 @@
+export default {}

package/google/protobuf/empty.pb.ts

@@ -0,0 +1,7 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+export type Empty = {
+}

package/kangaroo.io/api/harbor/v1alpha1/cluster.pb.ts

@@ -0,0 +1,44 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as KangarooIoApiTypesPage from "../../types/page.pb"
+
+export enum ListClusterRequestSortBy {
+  SORT_BY_UNSPECIFIED = "SORT_BY_UNSPECIFIED",
+  field_name = "field_name",
+  creation_time = "creation_time",
+}
+
+export enum ListNamespaceRequestSortBy {
+  SORT_BY_UNSPECIFIED = "SORT_BY_UNSPECIFIED",
+  field_name = "field_name",
+  creation_time = "creation_time",
+}
+
+export type ListClusterRequest = {
+  page?: number
+  pageSize?: number
+  sortBy?: ListClusterRequestSortBy
+  orderBy?: KangarooIoApiTypesPage.OrderBy
+}
+
+export type ListClusterResponse = {
+  items?: string[]
+  pagination?: KangarooIoApiTypesPage.Page
+}
+
+export type ListNamespaceRequest = {
+  cluster?: string
+  page?: number
+  pageSize?: number
+  sortBy?: ListNamespaceRequestSortBy
+  orderBy?: KangarooIoApiTypesPage.OrderBy
+}
+
+export type ListNamespaceResponse = {
+  items?: string[]
+  pagination?: KangarooIoApiTypesPage.Page
+}

package/kangaroo.io/api/harbor/v1alpha1/harbor.pb.ts

@@ -0,0 +1,227 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as KangarooIoApiTypesObjectmeta from "../../types/objectmeta.pb"
+import * as KangarooIoApiTypesPage from "../../types/page.pb"
+
+export enum DatabaseSpecDatabaseType {
+  DATABASE_UNSPECIFIED = "DATABASE_UNSPECIFIED",
+  BUILT_IN_MODE = "BUILT_IN_MODE",
+  MCAMEL_MODE = "MCAMEL_MODE",
+  EXTERNAL_MODE = "EXTERNAL_MODE",
+}
+
+export enum CacheSpecCacheType {
+  CACHE_UNSPECIFIED = "CACHE_UNSPECIFIED",
+  BUILT_IN_MODE = "BUILT_IN_MODE",
+  MCAMEL_MODE = "MCAMEL_MODE",
+  EXTERNAL_MODE = "EXTERNAL_MODE",
+}
+
+export enum OCIStorageSpecStorageType {
+  STORAGE_UNSPECIFIED = "STORAGE_UNSPECIFIED",
+  S3 = "S3",
+  STORAGE_CLASS = "STORAGE_CLASS",
+}
+
+export enum ExposeSpecExposeType {
+  EXPOSE_UNSPECIFIED = "EXPOSE_UNSPECIFIED",
+  INGRESS = "INGRESS",
+  LOAD_BALANCE = "LOAD_BALANCE",
+  NODE_PORT = "NODE_PORT",
+}
+
+export enum HarborClusterStatusClusterStatus {
+  CLUSTER_STATUS_UNSPECIFIED = "CLUSTER_STATUS_UNSPECIFIED",
+  PROVISIONING = "PROVISIONING",
+  HEALTHY = "HEALTHY",
+  UNHEALTHY = "UNHEALTHY",
+}
+
+export type GetHarborParamsRequest = {
+  cluster?: string
+}
+
+export type GetHarborParamsResponse = {
+  version?: string[]
+  storage?: ResourceNameList[]
+  ingress?: ResourceNameList[]
+}
+
+export type ResourceNameList = {
+  name?: string
+  default?: boolean
+}
+
+export type VerifyHarborOperatorRequest = {
+  cluster?: string
+  namespace?: string
+}
+
+export type VerifyHarborOperatorResponse = {
+  status?: boolean
+  message?: string
+}
+
+export type HarborCluster = {
+  metadata?: KangarooIoApiTypesObjectmeta.ObjectMeta
+  spec?: HarborClusterSpec
+  status?: HarborClusterStatus
+}
+
+export type HarborClusterSpec = {
+  version?: string
+  replicas?: number
+  resources?: Resources
+  database?: DatabaseSpec
+  cache?: CacheSpec
+  storage?: OCIStorageSpec
+  expose?: ExposeSpec
+  userSyncToHarbor?: boolean
+  adminPassword?: string
+}
+
+export type Resources = {
+  requests?: {[key: string]: string}
+  limits?: {[key: string]: string}
+}
+
+export type DatabaseSpec = {
+  type?: DatabaseSpecDatabaseType
+  inSpec?: DBBuiltInModeSpec
+  mcamelSpec?: DBMcamelModeSpec
+  externalSpec?: DBExternalModeSpec
+}
+
+export type DBBuiltInModeSpec = {
+}
+
+export type DBMcamelModeSpec = {
+}
+
+export type DBExternalModeSpec = {
+  hostAndPort?: string
+  username?: string
+  password?: string
+}
+
+export type CacheSpec = {
+  type?: CacheSpecCacheType
+  inSpec?: CacheBuiltInModeSpec
+  mcamelSpec?: CacheMcamelModeSpec
+  externalSpec?: CacheExternalModeSpec
+}
+
+export type CacheBuiltInModeSpec = {
+}
+
+export type CacheMcamelModeSpec = {
+}
+
+export type CacheExternalModeSpec = {
+  hostAndPort?: string
+  username?: string
+  password?: string
+}
+
+export type OCIStorageSpec = {
+  type?: OCIStorageSpecStorageType
+  s3Spec?: S3Spec
+  scSpec?: StorageClassSpec
+}
+
+export type StorageClassSpec = {
+  name?: string
+  resource?: Resources
+}
+
+export type S3Spec = {
+  accessKey?: string
+  secretKey?: string
+  region?: string
+  regionEndpoint?: string
+  bucket?: string
+  skipVerify?: boolean
+  v4Auth?: boolean
+}
+
+export type ExposeSpec = {
+  type?: ExposeSpecExposeType
+  ingressSpec?: ExposeIngressSpec
+  loadBalanceSpec?: ExposeLoadBalanceSpec
+  nodePortSpec?: ExposeNodePortSpec
+}
+
+export type ExposeIngressSpec = {
+  host?: string
+  ingressClassName?: string
+}
+
+export type ExposeLoadBalanceSpec = {
+}
+
+export type ExposeNodePortSpec = {
+}
+
+export type HarborClusterStatus = {
+  status?: HarborClusterStatusClusterStatus
+}
+
+export type CreateHarborClusterRequest = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  metadata?: KangarooIoApiTypesObjectmeta.ObjectMeta
+  spec?: HarborClusterSpec
+}
+
+export type UpdateHarborClusterRequest = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  spec?: HarborClusterSpec
+}
+
+export type GetHarborClusterRequest = {
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type DeleteHarborCluster = {
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type ListHarborClusterRequest = {
+  page?: number
+  pageSize?: number
+  sortBy?: KangarooIoApiTypesPage.SortBy
+  orderBy?: KangarooIoApiTypesPage.OrderBy
+}
+
+export type ListHarborClusterResponse = {
+  items?: HarborCluster[]
+  pagination?: KangarooIoApiTypesPage.Page
+}
+
+export type GetStorageStatisticRequest = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  start?: string
+  end?: string
+}
+
+export type GetStorageStatisticResponse = {
+  data?: StorageStatisticItem[]
+}
+
+export type StorageStatisticItem = {
+  timestamp?: string
+  value?: string
+}

package/kangaroo.io/api/harbor/v1alpha1/project.pb.ts

@@ -0,0 +1,85 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as KangarooIoApiTypesPage from "../../types/page.pb"
+
+export enum ListProjectRequestSortBy {
+  SORT_BY_UNSPECIFIED = "SORT_BY_UNSPECIFIED",
+  field_name = "field_name",
+  creation_time = "creation_time",
+}
+
+export type Project = {
+  chartCount?: string
+  creationTime?: string
+  currentUserRoleID?: string
+  currentUserRoleIds?: number[]
+  cVEAllowList?: CVEAllowList
+  deleted?: boolean
+  metadata?: ProjectMetadata
+  name?: string
+  ownerID?: number
+  ownerName?: string
+  projectID?: number
+  registryID?: string
+  repoCount?: string
+  togglable?: boolean
+  updateTime?: string
+}
+
+export type CVEAllowList = {
+  creationTime?: string
+  expiresAt?: string
+  id?: string
+  items?: CVEAllowListItem[]
+  projectID?: string
+  updateTime?: string
+}
+
+export type CVEAllowListItem = {
+  cVEID?: string
+}
+
+export type ProjectMetadata = {
+  autoScan?: string
+  enableContentTrust?: string
+  enableContentTrustCosign?: string
+  preventVul?: string
+  public?: string
+  retentionID?: string
+  reuseSysCVEAllowList?: string
+  severity?: string
+}
+
+export type ListProjectRequest = {
+  cluster?: string
+  namespace?: string
+  harbor?: string
+  page?: number
+  pageSize?: number
+  sortBy?: ListProjectRequestSortBy
+  orderBy?: KangarooIoApiTypesPage.OrderBy
+}
+
+export type ListProjectResponse = {
+  items?: Project[]
+  pagination?: KangarooIoApiTypesPage.Page
+}
+
+export type DeleteProjectRequest = {
+  cluster?: string
+  namespace?: string
+  harbor?: string
+  name?: string
+}
+
+export type CreateProjectRequest = {
+  cluster?: string
+  namespace?: string
+  harbor?: string
+  name?: string
+  public?: boolean
+}

package/kangaroo.io/api/harbor/v1alpha1/repository.pb.ts

@@ -0,0 +1,48 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as KangarooIoApiTypesPage from "../../types/page.pb"
+
+export enum ListRepositoriesRequestSortBy {
+  SORT_BY_UNSPECIFIED = "SORT_BY_UNSPECIFIED",
+  name = "name",
+  creation_time = "creation_time",
+}
+
+export type Repository = {
+  artifactCount?: string
+  creationTime?: string
+  description?: string
+  id?: string
+  name?: string
+  projectId?: string
+  pullCount?: string
+  updateTime?: string
+}
+
+export type ListRepositoriesRequest = {
+  cluster?: string
+  namespace?: string
+  harbor?: string
+  project?: string
+  page?: number
+  pageSize?: number
+  sortBy?: ListRepositoriesRequestSortBy
+  orderBy?: KangarooIoApiTypesPage.OrderBy
+}
+
+export type ListRepositoriesResponse = {
+  items?: Repository[]
+  pagination?: KangarooIoApiTypesPage.Page
+}
+
+export type DeleteRepositoryRequest = {
+  cluster?: string
+  namespace?: string
+  harbor?: string
+  project?: string
+  name?: string
+}

package/kangaroo.io/api/harbor/v1alpha1/rpc.pb.ts

@@ -0,0 +1,63 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as fm from "../../../../fetch.pb"
+import * as GoogleProtobufEmpty from "../../../../google/protobuf/empty.pb"
+import * as KangarooIoApiHarborV1alpha1Cluster from "./cluster.pb"
+import * as KangarooIoApiHarborV1alpha1Harbor from "./harbor.pb"
+import * as KangarooIoApiHarborV1alpha1Project from "./project.pb"
+import * as KangarooIoApiHarborV1alpha1Repository from "./repository.pb"
+export class Harbor {
+  static GetHarborParams(req: KangarooIoApiHarborV1alpha1Harbor.GetHarborParamsRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Harbor.GetHarborParamsResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.GetHarborParamsRequest, KangarooIoApiHarborV1alpha1Harbor.GetHarborParamsResponse>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/harbors/default-params?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static VerifyHarborOperator(req: KangarooIoApiHarborV1alpha1Harbor.VerifyHarborOperatorRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Harbor.VerifyHarborOperatorResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.VerifyHarborOperatorRequest, KangarooIoApiHarborV1alpha1Harbor.VerifyHarborOperatorResponse>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/check?${fm.renderURLSearchParams(req, ["cluster", "namespace"])}`, {...initReq, method: "GET"})
+  }
+  static GetHarborCluster(req: KangarooIoApiHarborV1alpha1Harbor.GetHarborClusterRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Harbor.HarborCluster> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.GetHarborClusterRequest, KangarooIoApiHarborV1alpha1Harbor.HarborCluster>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static ListHarborClusters(req: KangarooIoApiHarborV1alpha1Harbor.ListHarborClusterRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Harbor.ListHarborClusterResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.ListHarborClusterRequest, KangarooIoApiHarborV1alpha1Harbor.ListHarborClusterResponse>(`/apis/kangaroo.io/v1alpha1/harbors?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static CreateHarborCluster(req: KangarooIoApiHarborV1alpha1Harbor.CreateHarborClusterRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Harbor.HarborCluster> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.CreateHarborClusterRequest, KangarooIoApiHarborV1alpha1Harbor.HarborCluster>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["name"]}`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static UpdateHarborCluster(req: KangarooIoApiHarborV1alpha1Harbor.UpdateHarborClusterRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Harbor.HarborCluster> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.UpdateHarborClusterRequest, KangarooIoApiHarborV1alpha1Harbor.HarborCluster>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["name"]}`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static DeleteHarborCluster(req: KangarooIoApiHarborV1alpha1Harbor.DeleteHarborCluster, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.DeleteHarborCluster, GoogleProtobufEmpty.Empty>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+  static ListCluster(req: KangarooIoApiHarborV1alpha1Cluster.ListClusterRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Cluster.ListClusterResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Cluster.ListClusterRequest, KangarooIoApiHarborV1alpha1Cluster.ListClusterResponse>(`/apis/kangaroo.io/v1alpha1/cluster?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static ListNamespace(req: KangarooIoApiHarborV1alpha1Cluster.ListNamespaceRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Cluster.ListNamespaceResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Cluster.ListNamespaceRequest, KangarooIoApiHarborV1alpha1Cluster.ListNamespaceResponse>(`/apis/kangaroo.io/v1alpha1/cluster/${req["cluster"]}/namespace?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetStorageStatistic(req: KangarooIoApiHarborV1alpha1Harbor.GetStorageStatisticRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Harbor.GetStorageStatisticResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Harbor.GetStorageStatisticRequest, KangarooIoApiHarborV1alpha1Harbor.GetStorageStatisticResponse>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["name"]}/storage_statistic?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+}
+export class HarborProject {
+  static ListProject(req: KangarooIoApiHarborV1alpha1Project.ListProjectRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Project.ListProjectResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Project.ListProjectRequest, KangarooIoApiHarborV1alpha1Project.ListProjectResponse>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["harbor"]}/projects?${fm.renderURLSearchParams(req, ["cluster", "namespace", "harbor"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteProject(req: KangarooIoApiHarborV1alpha1Project.DeleteProjectRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Project.DeleteProjectRequest, GoogleProtobufEmpty.Empty>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["harbor"]}/projects/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+  static CreateProject(req: KangarooIoApiHarborV1alpha1Project.CreateProjectRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Project.Project> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Project.CreateProjectRequest, KangarooIoApiHarborV1alpha1Project.Project>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["harbor"]}/project`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+}
+export class HarborRepository {
+  static ListRepositories(req: KangarooIoApiHarborV1alpha1Repository.ListRepositoriesRequest, initReq?: fm.InitReq): Promise<KangarooIoApiHarborV1alpha1Repository.ListRepositoriesResponse> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Repository.ListRepositoriesRequest, KangarooIoApiHarborV1alpha1Repository.ListRepositoriesResponse>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["harbor"]}/projects/${req["project"]}/repositories?${fm.renderURLSearchParams(req, ["cluster", "namespace", "harbor", "project"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteRepository(req: KangarooIoApiHarborV1alpha1Repository.DeleteRepositoryRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<KangarooIoApiHarborV1alpha1Repository.DeleteRepositoryRequest, GoogleProtobufEmpty.Empty>(`/apis/kangaroo.io/v1alpha1/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/harbors/${req["harbor"]}/projects/${req["project"]}/repositories/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+}

package/kangaroo.io/api/types/objectmeta.pb.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+export type ObjectMeta = {
+  name?: string
+  namespace?: string
+  cluster?: string
+  annotations?: {[key: string]: string}
+}

package/kangaroo.io/api/types/page.pb.ts

@@ -0,0 +1,23 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export enum OrderBy {
+  desc = "desc",
+  asc = "asc",
+}
+
+export enum SortBy {
+  SORT_BY_UNSPECIFIED = "SORT_BY_UNSPECIFIED",
+  field_name = "field_name",
+  created_at = "created_at",
+}
+
+export type Page = {
+  page?: number
+  size?: number
+  total?: number
+  pages?: number
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name":"@daocloud-proto/kangaroo",
+  "version":"0.1.1-10",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

package/protoc-gen-openapiv2/options/annotations.pb.ts

@@ -0,0 +1 @@
+export default {}

package/protoc-gen-validate/validate/validate.pb.ts

@@ -0,0 +1,266 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as GoogleProtobufDuration from "../../google/protobuf/duration.pb"
+import * as GoogleProtobufTimestamp from "../../google/protobuf/timestamp.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 KnownRegex {
+  UNKNOWN = "UNKNOWN",
+  HTTP_HEADER_NAME = "HTTP_HEADER_NAME",
+  HTTP_HEADER_VALUE = "HTTP_HEADER_VALUE",
+}
+
+
+type BaseFieldRules = {
+  message?: MessageRules
+}
+
+export type FieldRules = BaseFieldRules
+  & OneOf<{ float: FloatRules; double: DoubleRules; int32: Int32Rules; int64: Int64Rules; uint32: UInt32Rules; uint64: UInt64Rules; sint32: SInt32Rules; sint64: SInt64Rules; fixed32: Fixed32Rules; fixed64: Fixed64Rules; sfixed32: SFixed32Rules; sfixed64: SFixed64Rules; bool: BoolRules; string: StringRules; bytes: BytesRules; enum: EnumRules; repeated: RepeatedRules; map: MapRules; any: AnyRules; duration: DurationRules; timestamp: TimestampRules }>
+
+export type FloatRules = {
+  const?: number
+  lt?: number
+  lte?: number
+  gt?: number
+  gte?: number
+  in?: number[]
+  notIn?: number[]
+  ignoreEmpty?: boolean
+}
+
+export type DoubleRules = {
+  const?: number
+  lt?: number
+  lte?: number
+  gt?: number
+  gte?: number
+  in?: number[]
+  notIn?: number[]
+  ignoreEmpty?: boolean
+}
+
+export type Int32Rules = {
+  const?: number
+  lt?: number
+  lte?: number
+  gt?: number
+  gte?: number
+  in?: number[]
+  notIn?: number[]
+  ignoreEmpty?: boolean
+}
+
+export type Int64Rules = {
+  const?: string
+  lt?: string
+  lte?: string
+  gt?: string
+  gte?: string
+  in?: string[]
+  notIn?: string[]
+  ignoreEmpty?: boolean
+}
+
+export type UInt32Rules = {
+  const?: number
+  lt?: number
+  lte?: number
+  gt?: number
+  gte?: number
+  in?: number[]
+  notIn?: number[]
+  ignoreEmpty?: boolean
+}
+
+export type UInt64Rules = {
+  const?: string
+  lt?: string
+  lte?: string
+  gt?: string
+  gte?: string
+  in?: string[]
+  notIn?: string[]
+  ignoreEmpty?: boolean
+}
+
+export type SInt32Rules = {
+  const?: number
+  lt?: number
+  lte?: number
+  gt?: number
+  gte?: number
+  in?: number[]
+  notIn?: number[]
+  ignoreEmpty?: boolean
+}
+
+export type SInt64Rules = {
+  const?: string
+  lt?: string
+  lte?: string
+  gt?: string
+  gte?: string
+  in?: string[]
+  notIn?: string[]
+  ignoreEmpty?: boolean
+}
+
+export type Fixed32Rules = {
+  const?: number
+  lt?: number
+  lte?: number
+  gt?: number
+  gte?: number
+  in?: number[]
+  notIn?: number[]
+  ignoreEmpty?: boolean
+}
+
+export type Fixed64Rules = {
+  const?: string
+  lt?: string
+  lte?: string
+  gt?: string
+  gte?: string
+  in?: string[]
+  notIn?: string[]
+  ignoreEmpty?: boolean
+}
+
+export type SFixed32Rules = {
+  const?: number
+  lt?: number
+  lte?: number
+  gt?: number
+  gte?: number
+  in?: number[]
+  notIn?: number[]
+  ignoreEmpty?: boolean
+}
+
+export type SFixed64Rules = {
+  const?: string
+  lt?: string
+  lte?: string
+  gt?: string
+  gte?: string
+  in?: string[]
+  notIn?: string[]
+  ignoreEmpty?: boolean
+}
+
+export type BoolRules = {
+  const?: boolean
+}
+
+
+type BaseStringRules = {
+  const?: string
+  len?: string
+  minLen?: string
+  maxLen?: string
+  lenBytes?: string
+  minBytes?: string
+  maxBytes?: string
+  pattern?: string
+  prefix?: string
+  suffix?: string
+  contains?: string
+  notContains?: string
+  in?: string[]
+  notIn?: string[]
+  strict?: boolean
+  ignoreEmpty?: boolean
+}
+
+export type StringRules = BaseStringRules
+  & OneOf<{ email: boolean; hostname: boolean; ip: boolean; ipv4: boolean; ipv6: boolean; uri: boolean; uriRef: boolean; address: boolean; uuid: boolean; wellKnownRegex: KnownRegex }>
+
+
+type BaseBytesRules = {
+  const?: Uint8Array
+  len?: string
+  minLen?: string
+  maxLen?: string
+  pattern?: string
+  prefix?: Uint8Array
+  suffix?: Uint8Array
+  contains?: Uint8Array
+  in?: Uint8Array[]
+  notIn?: Uint8Array[]
+  ignoreEmpty?: boolean
+}
+
+export type BytesRules = BaseBytesRules
+  & OneOf<{ ip: boolean; ipv4: boolean; ipv6: boolean }>
+
+export type EnumRules = {
+  const?: number
+  definedOnly?: boolean
+  in?: number[]
+  notIn?: number[]
+}
+
+export type MessageRules = {
+  skip?: boolean
+  required?: boolean
+}
+
+export type RepeatedRules = {
+  minItems?: string
+  maxItems?: string
+  unique?: boolean
+  items?: FieldRules
+  ignoreEmpty?: boolean
+}
+
+export type MapRules = {
+  minPairs?: string
+  maxPairs?: string
+  noSparse?: boolean
+  keys?: FieldRules
+  values?: FieldRules
+  ignoreEmpty?: boolean
+}
+
+export type AnyRules = {
+  required?: boolean
+  in?: string[]
+  notIn?: string[]
+}
+
+export type DurationRules = {
+  required?: boolean
+  const?: GoogleProtobufDuration.Duration
+  lt?: GoogleProtobufDuration.Duration
+  lte?: GoogleProtobufDuration.Duration
+  gt?: GoogleProtobufDuration.Duration
+  gte?: GoogleProtobufDuration.Duration
+  in?: GoogleProtobufDuration.Duration[]
+  notIn?: GoogleProtobufDuration.Duration[]
+}
+
+export type TimestampRules = {
+  required?: boolean
+  const?: GoogleProtobufTimestamp.Timestamp
+  lt?: GoogleProtobufTimestamp.Timestamp
+  lte?: GoogleProtobufTimestamp.Timestamp
+  gt?: GoogleProtobufTimestamp.Timestamp
+  gte?: GoogleProtobufTimestamp.Timestamp
+  ltNow?: boolean
+  gtNow?: boolean
+  within?: GoogleProtobufDuration.Duration
+}