@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/core/types/k8s/raw.d.ts

@@ -0,0 +1,975 @@
+/**
+ * 此文件只维护 所有的 k8s 原生类型
+ */
+import { StringMap } from '../commons';
+import { ValueOf } from '../helpers';
+import { OpenAPIV3SchemaObject } from '../schema';
+import { KubernetesResource, LabelSelector, LabelSelectorRequirement, ObjectMeta, ObjectReference, Condition } from './core';
+export interface Secret<T = StringMap> extends KubernetesResource {
+    data?: T;
+    stringData?: StringMap;
+    type?: SecretType;
+    global?: boolean;
+    certificate?: Certificate;
+}
+export interface Namespace extends KubernetesResource {
+    status?: NamespaceStatus;
+}
+export interface NamespaceStatus {
+    phase?: string;
+}
+export interface ScopedResourceSelectorRequirement {
+    operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+    scopeName: string;
+    values: string;
+}
+export interface ScopeSelector {
+    matchExpressions: ScopedResourceSelectorRequirement[];
+}
+export declare enum K8sResourceAction {
+    GET = "get",
+    LIST = "list",
+    WATCH = "watch",
+    CREATE = "create",
+    UPDATE = "update",
+    PATCH = "patch",
+    DELETE = "delete",
+    DELETE_COLLECTION = "deletecollection",
+    PROXY = "proxy",
+    REDIRECT = "redirect",
+    ALL = "*"
+}
+export declare enum SecretType {
+    Opaque = "Opaque",
+    TLS = "kubernetes.io/tls",
+    SSHKey = "kubernetes.io/ssh-public-key",
+    SSHAuth = "kubernetes.io/ssh-auth",
+    BasicAuth = "kubernetes.io/basic-auth",
+    Database = "kubernetes.io/database",
+    DockerConfigJson = "kubernetes.io/dockerconfigjson",
+    OAuth2 = "katanomi.dev/oauth2",
+    NoAuth = "kubernetes.io/no-auth",
+    DevOpsOAuth2 = "devops.alauda.io/oauth2",
+    DynamicSecretKey = "katanomi.dev/dynamic",
+    CloudCredential = "CloudCredential"
+}
+export interface StatefulSet extends KubernetesResource {
+    spec?: StatefulSetSpec;
+    status?: StatefulSetStatus;
+}
+export interface StatefulSetSpec {
+    replicas?: number;
+    selector?: LabelSelector;
+    template?: PodTemplateSpec;
+    serviceName?: string;
+    updateStrategy?: StatefulSetUpdateStrategy;
+    revisionHistoryLimit?: number;
+    volumeClaimTemplates?: PersistentVolumeClaim[];
+}
+export interface PodTemplateSpec extends KubernetesResource {
+    spec?: PodSpec;
+}
+export interface PodSpec {
+    containers?: Container[];
+    initContainers?: Container[];
+    ephemeralContainers?: EphemeralContainer[];
+    volumes?: Volume[];
+    hostAliases?: HostAliases[];
+    nodeSelector?: StringMap;
+    hostNetwork?: boolean;
+    affinity?: Affinity;
+    restartPolicy?: string;
+    imagePullSecrets?: LocalObjectReference[];
+    serviceAccountName?: string;
+    serviceAccount?: string;
+    nodeName?: string;
+    terminationGracePeriodSeconds?: number;
+    tolerations?: Toleration[];
+}
+export interface Toleration {
+    key?: string;
+    value?: string;
+    operator?: TolerationOperator;
+    tolerationSeconds?: number;
+    effect?: TaintEffect;
+}
+export declare enum TolerationOperator {
+    Exists = "Exists",
+    Equal = "Equal"
+}
+export declare enum TaintEffect {
+    NoSchedule = "NoSchedule",
+    PreferNoSchedule = "PreferNoSchedule",
+    NoExecute = "NoExecute"
+}
+export interface Container {
+    name?: string;
+    image?: string;
+    command?: string[];
+    args?: string[];
+    env?: EnvVar[];
+    envFrom?: EnvFromSource[];
+    workingDir?: string;
+    ports?: ContainerPort[];
+    resources?: ResourceRequirements;
+    volumeMounts?: VolumeMount[];
+    livenessProbe?: Probe;
+    readinessProbe?: Probe;
+    lifecycle?: PodLifeCycle;
+}
+export interface EnvVarSource {
+    configMapKeyRef?: ConfigMapKeyRef;
+    secretKeyRef?: SecretKeyRef;
+    fieldRef?: ObjectFieldSelector;
+    resourceFieldRef?: ResourceFieldSelector;
+}
+export interface EnvVar {
+    name: string;
+    value?: string;
+    valueFrom?: EnvVarSource;
+}
+export interface EnvFromSource {
+    prefix?: string;
+    configMapRef?: ConfigMapRef;
+    secretRef?: SecretRef;
+}
+export interface PodLifeCycle {
+    postStart?: PodLifeCycleHook;
+    preStop?: PodLifeCycleHook;
+}
+export interface PodLifeCycleHook {
+    exec: {
+        command: string[];
+    };
+}
+export interface HTTPGetAction {
+    host?: string;
+    httpHeaders?: HTTPHeader[];
+    path: string;
+    port?: number | string;
+    scheme?: string;
+}
+export interface EphemeralContainer {
+    command: string[];
+    image: string;
+    imagePullPolicy: string;
+    name: string;
+    stdin: boolean;
+    tty: boolean;
+    terminationMessagePolicy?: string;
+    [key: string]: unknown;
+}
+export type StatefulSetStatus = Partial<{
+    collisionCount: number;
+    observedGeneration: number;
+    replicas: number;
+    readyReplicas: number;
+    currentReplicas: number;
+    currentRevision: string;
+    updateRevision: string;
+    updatedReplicas?: number;
+}>;
+export type DeploymentStrategyType = 'RollingUpdate' | 'Recreate';
+export type DaemonSetUpdateStrategyType = 'RollingUpdate' | 'OnDelete';
+export type StatefulSetUpdateStrategyType = 'RollingUpdate' | 'OnDelete';
+export interface DeploymentStrategy {
+    type?: DeploymentStrategyType;
+    rollingUpdate?: RollingUpdateDeployment;
+}
+export interface RollingUpdateDeployment {
+    maxUnavailable?: string | number;
+    maxSurge?: string | number;
+}
+export interface StatefulSetUpdateStrategy {
+    type?: StatefulSetUpdateStrategyType;
+    rollingUpdate?: RollingUpdateStatefulSetStrategy;
+}
+export interface RollingUpdateStatefulSetStrategy {
+    partition?: string | number;
+}
+export interface Ingress extends KubernetesResource {
+    spec?: IngressSpec;
+}
+export interface IngressSpec {
+    ingressClassName?: string;
+    rules?: IngressRule[];
+    tls?: IngressTLS[];
+}
+export interface IngressRule {
+    host?: string;
+    http: HTTPIngressRuleValue;
+}
+export interface HTTPIngressRuleValue {
+    paths: HTTPIngressPath[];
+}
+export interface HTTPIngressPath {
+    path: string;
+    pathType: 'Prefix' | 'Exact' | 'ImplementationSpecific';
+    backend: IngressBackend;
+}
+export interface IngressBackend {
+    serviceName?: string;
+    servicePort?: number;
+    service?: {
+        name: string;
+        port: {
+            number: number;
+        };
+    };
+}
+export interface IngressTLS {
+    hosts?: string[];
+    secretName?: string;
+    global?: boolean;
+    certificate?: Certificate;
+}
+export interface IngressStatus {
+    loadBalancer?: IngressLoadBalancerStatus;
+}
+export interface IngressLoadBalancerStatus {
+    ingress?: LoadBalancerIngress[];
+}
+export interface LoadBalancerIngress {
+    ip: string;
+    hostname: string;
+}
+export declare const VolumeMode: {
+    readonly FILE_SYSTEM: "Filesystem";
+    readonly BLOCK_DEVICE: "Block";
+};
+export type VolumeMode = ValueOf<typeof VolumeMode>;
+export declare const VolumeModes: ("Filesystem" | "Block")[];
+export declare const AccessMode: {
+    readonly RWO: "ReadWriteOnce";
+    readonly ROX: "ReadOnlyMany";
+    readonly RWX: "ReadWriteMany";
+};
+export type AccessMode = ValueOf<typeof AccessMode>;
+export declare const AccessModes: ("ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany")[];
+export interface PersistentVolumeClaim extends KubernetesResource {
+    spec: PersistentVolumeClaimSpec;
+    status?: PersistentVolumeClaimStatus;
+}
+export interface PersistentVolumeClaimStatus {
+    phase: string;
+    capacity?: {
+        storage: string;
+    };
+}
+export interface PersistentVolumeClaimSpec {
+    storageClassName?: string;
+    volumeName?: string;
+    resources: {
+        requests: {
+            storage: string;
+        };
+    };
+    dataSource?: PersistentVolumeClaimDataSource;
+    selector?: LabelSelector;
+    accessModes: AccessMode[];
+    volumeMode?: VolumeMode;
+}
+export interface PersistentVolumeClaimDataSource {
+    name: string;
+    kind: string;
+    apiGroup: string;
+}
+export interface APIResourceItem {
+    name: string;
+    singularName: string;
+    namespaced: boolean;
+    kind: string;
+    verbs: K8sResourceAction[];
+    groupVersion?: string[];
+}
+export interface APIResourceList extends KubernetesResource {
+    kind: 'APIResourceList';
+    apiVersion?: string;
+    groupVersion: string;
+    resources: APIResourceItem[];
+}
+export interface ResourceAttributes<T extends K8sResourceAction> {
+    group: string;
+    resource: string;
+    verb: T;
+    namespace?: string;
+    name?: string;
+}
+export interface SubjectAccessReviewSpec<T extends K8sResourceAction> {
+    resourceAttributes: ResourceAttributes<T>;
+}
+export interface SubjectAccessReviewStatus {
+    allowed: boolean;
+    denied?: boolean;
+    evaluationError?: string;
+    reason?: string;
+}
+export interface SubjectAccessReview<T extends K8sResourceAction = K8sResourceAction> extends KubernetesResource {
+    kind: 'SubjectAccessReview';
+    spec: SubjectAccessReviewSpec<T>;
+    status: SubjectAccessReviewStatus;
+}
+export interface SelfResourceAttributes<T extends K8sResourceAction> extends ResourceAttributes<T> {
+    project?: string;
+    cluster?: string;
+}
+export interface SelfSubjectAccessReviewSpec<T extends K8sResourceAction> extends SubjectAccessReviewSpec<T> {
+    resourceAttributes: SelfResourceAttributes<T>;
+}
+export interface SelfSubjectAccessReview<T extends K8sResourceAction = K8sResourceAction> extends KubernetesResource {
+    kind: 'SelfSubjectAccessReview';
+    spec: SelfSubjectAccessReviewSpec<T>;
+    status: SubjectAccessReviewStatus;
+}
+export declare enum DependencyType {
+    Any = "any",
+    All = "all"
+}
+export declare enum FeatureStage {
+    Alpha = "Alpha",
+    Beta = "Beta",
+    GA = "GA",
+    EOF = "EOF"
+}
+export interface FeatureGate extends KubernetesResource {
+    spec: {
+        dependency: {
+            type: DependencyType;
+            featureGates: string[];
+        };
+        description: string;
+        enabled: boolean;
+        stage: FeatureStage;
+    };
+    status: {
+        enabled: boolean;
+    };
+}
+export interface FeatureGateEnterpriseSupport extends KubernetesResource {
+    spec: FeatureGateEnterpriseSupportSpec;
+    status: FeatureGateEnterpriseSupportStatus;
+}
+export interface FeatureGateEnterpriseSupportSpec {
+    products: Array<{
+        name: string;
+    }>;
+    validity: {
+        notBefore: string;
+        notAfter: string;
+    };
+    type: string;
+    name: string;
+    version: string;
+    licenseKind: string;
+    baremetalClusterCPUCoreLimit: number;
+    importedClusterNodeLimit: number;
+    allowProductVersion: string;
+}
+export interface FeatureGateEnterpriseSupportStatus {
+    phase: EnterpriseSupportStatusType;
+    reason: EnterpriseSupportStatusReason[];
+    baremetalClusterCPUCoreNum: number;
+    importedClusterNodeNum: number;
+    CurrentProductVersion: string;
+}
+export declare enum EnterpriseSupportStatusType {
+    inService = "InService",
+    outOfService = "OutOfService",
+    warning = "Warning"
+}
+export declare enum EnterpriseSupportStatusReason {
+    ExceedResourceLimit = "ExceedResourceLimit",
+    ExceedNodeLimit = "ExceedNodeLimit",
+    MismatchProductVersion = "MismatchProductVersion",
+    MismatchSubProducts = "MismatchSubProducts",
+    NotExist = "NotExist",
+    Expired = "Expired",
+    Pending = "Pending",
+    ExpiringSoon = "ExpiringSoon"
+}
+export declare enum SecurityPolicyRuleName {
+    password = "PasswordPolicy",
+    lock = "UserLockedPolicy",
+    disable = "UserDisabledPolicy",
+    notification = "NotificationPolicy",
+    access = "AccessControlPolicy"
+}
+export interface SecurityPolicyRule {
+    name: SecurityPolicyRuleName;
+    items: Array<{
+        enable: boolean;
+        key: string;
+        value: string;
+    }>;
+}
+export interface SecurityPolicyResource extends KubernetesResource {
+    rules: SecurityPolicyRule[];
+}
+export interface Status {
+    kind: 'Status';
+    apiVersion: string;
+    metadata: {
+        continue?: string;
+    };
+    status: string;
+    message: string;
+    reason: string;
+    code: number;
+    details?: {
+        group?: string;
+        kind: string;
+        name: string;
+        uid: string;
+        causes: Array<{
+            message?: string;
+            reason?: string;
+            field?: string;
+        }>;
+    };
+}
+export interface LocalObjectReference {
+    name: string;
+}
+export interface ConfigMapKeyRef extends LocalObjectReference {
+    key: string;
+    optional?: boolean;
+}
+export interface SecretKeyRef extends LocalObjectReference {
+    key: string;
+    optional?: boolean;
+}
+export interface ConfigMapRef extends LocalObjectReference {
+    optional?: boolean;
+}
+export interface SecretRef extends LocalObjectReference {
+    optional?: boolean;
+}
+export interface ObjectFieldSelector {
+    apiVersion?: string;
+    fieldPath: string;
+}
+export interface ResourceFieldSelector {
+    containerName?: string;
+    divisor?: string;
+    resource: string;
+}
+/**
+ * Workload API
+ */
+export interface Deployment extends KubernetesResource {
+    name?: string;
+    spec?: DeploymentSpec;
+    status?: DeploymentStatus;
+    generation?: number;
+}
+export interface DeploymentSpec {
+    replicas?: number;
+    selector?: LabelSelector;
+    template?: PodTemplateSpec;
+    strategy?: DeploymentStrategy;
+    minReadySeconds?: number;
+    revisionHistoryLimit?: number;
+}
+export interface Pod extends KubernetesResource {
+    spec?: PodSpec;
+    status?: PodStatus;
+}
+export interface PodStatus {
+    conditions?: Condition[];
+    containerStatuses?: ContainerStatus[];
+    hostIP?: string;
+    initContainerStatuses?: ContainerStatus[];
+    ephemeralContainerStatuses?: ContainerStatus[];
+    message?: string;
+    nominatedNodeName?: string;
+    phase?: string;
+    podIP?: string;
+    podIPs?: Array<{
+        ip: string;
+    }>;
+    qosClass?: string;
+    reason?: string;
+    startTime?: string;
+}
+export interface HostAliases {
+    ip: string;
+    hostnames: string[];
+}
+export interface ContainerStatus {
+    containerID?: string;
+    image?: string;
+    imageID?: string;
+    lastState?: ContainerState;
+    name?: string;
+    ready?: boolean;
+    restartCount?: number;
+    state?: ContainerState;
+}
+export interface ContainerState {
+    running?: ContainerStateRunning;
+    terminated?: ContainerStateTerminated;
+    waiting?: ContainerStateWaiting;
+}
+export interface ContainerStateRunning {
+    startedAt?: string;
+}
+export interface ContainerStateTerminated {
+    containerID?: string;
+    exitCode?: number;
+    finishedAt?: string;
+    message?: string;
+    reason?: string;
+    signal?: number;
+    startedAt?: string;
+}
+export interface ContainerStateWaiting {
+    message?: string;
+    reason?: string;
+}
+export interface DeploymentStatus {
+    availableReplicas?: number;
+    collisionCount?: number;
+    observedGeneration?: number;
+    readyReplicas?: number;
+    replicas?: number;
+    unavailableReplicas?: number;
+    updatedReplicas?: number;
+    conditions?: Condition[];
+}
+export interface RequiredAffinity {
+    topologyKey: string;
+    labelSelector: LabelSelector;
+}
+export interface PreferredAffinity {
+    weight: number;
+    podAffinityTerm: {
+        labelSelector?: LabelSelector;
+        topologyKey: string;
+    };
+}
+export interface PodAffinity {
+    requiredDuringSchedulingIgnoredDuringExecution?: RequiredAffinity[];
+    preferredDuringSchedulingIgnoredDuringExecution?: PreferredAffinity[];
+}
+export interface PodSpecAffinity {
+    podAffinity?: Affinity;
+    podAntiAffinity?: Affinity;
+    nodeAffinity?: Affinity;
+}
+export interface Affinity {
+    requiredDuringSchedulingIgnoredDuringExecution?: PodAffinityTerm[] | NodeAffinityTerm;
+    preferredDuringSchedulingIgnoredDuringExecution?: WeightedPodAffinityTerm[];
+}
+export interface WeightedNodeAffinityTerm {
+    weight: number;
+    preference: NodeSelectorTerm;
+}
+export interface NodeAffinity {
+    requiredDuringSchedulingIgnoredDuringExecution?: NodeAffinityTerm;
+    preferredDuringSchedulingIgnoredDuringExecution?: WeightedNodeAffinityTerm[];
+}
+export interface WeightedPodAffinityTerm {
+    podAffinityTerm: PodAffinityTerm;
+    weight: number;
+}
+export interface PodAffinityTerm {
+    labelSelector?: LabelSelector;
+    topologyKey: string;
+    namespaces?: string[];
+}
+export interface NodeAffinityTerm {
+    nodeSelectorTerms: NodeSelectorTerm[];
+}
+export interface NodeSelectorTerm {
+    matchExpressions: LabelSelectorRequirement[];
+}
+export declare enum VolumeTypeEnum {
+    persistentVolumeClaim = "persistentVolumeClaim",
+    configMap = "configMap",
+    secret = "secret",
+    ephemeral = "ephemeral",
+    emptyDir = "emptyDir",
+    hostPath = "hostPath"
+}
+export interface Volume {
+    name: string;
+    [VolumeTypeEnum.emptyDir]?: EmptyDirVolumeSource;
+    [VolumeTypeEnum.configMap]?: ConfigMapVolumeSource;
+    [VolumeTypeEnum.secret]?: SecretVolumeSource;
+    [VolumeTypeEnum.persistentVolumeClaim]?: PersistentVolumeClaimVolumeSource;
+    [VolumeTypeEnum.hostPath]?: HostPathVolumeSource;
+    [VolumeTypeEnum.ephemeral]?: EphemeralVolumeSource;
+    isAppResource?: boolean;
+    mountPath?: string;
+}
+export interface CsiVolumeSource {
+    driver: 'objectstorage.k8s.io';
+    volumeAttributes: {
+        'bar-name': string;
+        'bar-namespace': string;
+        bucketRequestName: string;
+    };
+}
+export interface KeyToPath {
+    key?: string;
+    mode?: number;
+    path?: string;
+}
+export interface EmptyDirVolumeSource {
+    medium?: string;
+    sizeLimit?: string;
+}
+export interface ConfigMapVolumeSource {
+    name: string;
+    optional?: boolean;
+    items?: KeyToPath[];
+}
+export interface SecretVolumeSource {
+    secretName: string;
+    optional?: boolean;
+    items?: KeyToPath[];
+}
+export interface HostPathVolumeSource {
+    type?: string;
+    path: string;
+}
+export interface PersistentVolumeClaimVolumeSource {
+    claimName: string;
+    readOnly?: boolean;
+}
+export interface EphemeralVolumeSource {
+    volumeClaimTemplate: PersistentVolumeClaim;
+}
+export interface Probe {
+    exec?: ExecAction;
+    failureThreshold?: number;
+    httpGet?: HTTPGetAction;
+    initialDelaySeconds?: number;
+    periodSeconds?: number;
+    successThreshold?: number;
+    tcpSocket?: TCPSocketAction;
+    timeoutSeconds?: number;
+}
+export interface ExecAction {
+    command?: string[];
+}
+export interface HTTPHeader {
+    name?: string;
+    value?: string;
+}
+export interface TCPSocketAction {
+    host?: string;
+    port?: number | string;
+}
+export interface VolumeMount {
+    name: string;
+    mountPath?: string;
+    readOnly?: boolean;
+    subPath?: string;
+    mountPropagation?: string;
+}
+export interface ResourceRequirements {
+    limits?: StringMap;
+    requests?: StringMap;
+}
+export interface ContainerPort {
+    name?: string;
+    hostPort?: number;
+    containerPort?: number;
+    servicePort?: number;
+    protocol?: 'TCP' | 'UDP';
+    hostIP?: string;
+}
+export interface Certificate {
+    name: string;
+    namespace: string;
+    notBefore: string;
+    notAfter: string;
+    dnsNames: string[];
+    valid: boolean;
+    reasonCode?: 1 | 2 | 3;
+}
+export declare const AlbProtocolMapper: {
+    readonly http: "HTTP";
+    readonly https: "HTTPS";
+    readonly grpc: "gRPC";
+    readonly tcp: "TCP";
+    readonly udp: "UDP";
+};
+export type AlbProtocol = keyof typeof AlbProtocolMapper;
+export interface FrontendSpec {
+    port?: number | '';
+    protocol?: AlbProtocol;
+    source?: {
+        name: string;
+        namespace: string;
+        type: string;
+    };
+    backendProtocol?: 'HTTP' | 'HTTPS' | 'gRPC';
+    serviceGroup?: ServiceGroup;
+    certificate_name?: string;
+}
+export interface RuleService {
+    name: string;
+    namespace: string;
+    port: number;
+    weight: number;
+}
+export interface ServiceGroup {
+    services: RuleService[];
+    session_affinity_policy?: string;
+    session_affinity_attribute?: string;
+}
+export interface RollingUpdateDaemonSet {
+    maxUnavailable?: string | number;
+}
+export interface DaemonSetUpdateStrategy {
+    type?: DaemonSetUpdateStrategyType;
+    rollingUpdate?: RollingUpdateDaemonSet;
+}
+export interface DaemonSet extends KubernetesResource {
+    spec?: DaemonSetSpec;
+    status?: DaemonSetStatus;
+}
+export interface DaemonSetSpec {
+    selector?: LabelSelector;
+    template?: PodTemplateSpec;
+    updateStrategy?: DaemonSetUpdateStrategy;
+    minReadySeconds?: number;
+    revisionHistoryLimit?: number;
+}
+export type DaemonSetStatus = Partial<{
+    currentNumberScheduled: number;
+    numberMisscheduled: number;
+    desiredNumberScheduled: number;
+    numberReady: number;
+    observedGeneration: number;
+    updatedNumberScheduled: number;
+    numberUnavailable: number;
+    numberAvailable: number;
+}>;
+export interface ConfigMap<T = StringMap> extends KubernetesResource {
+    data?: T;
+    binaryData?: StringMap;
+}
+export interface CronJobSpec {
+    concurrencyPolicy?: string;
+    failedJobsHistoryLimit?: number | '';
+    schedule?: string;
+    startingDeadlineSeconds?: number | '';
+    successfulJobsHistoryLimit?: number | '';
+    suspend?: boolean;
+    timeZone?: string;
+    jobTemplate?: JobTemplateSpec;
+}
+export interface Job extends KubernetesResource {
+    spec?: JobSpec;
+    status?: JobStatus;
+}
+export interface JobSpec {
+    activeDeadlineSeconds?: number | '';
+    backoffLimit?: number | '';
+    completions?: number | '';
+    manualSelector?: boolean;
+    parallelism?: number | '';
+    selector?: LabelSelector;
+    template?: PodTemplateSpec;
+    startingDeadlineSeconds?: number | '';
+}
+export interface JobTemplateSpec {
+    metadata?: ObjectMeta;
+    spec?: JobSpec;
+}
+export interface JobStatus {
+    active: number | '';
+    completionTime: string;
+    conditions: Condition[];
+    startTime: string;
+    succeeded: number;
+    failed: number;
+}
+export interface CronJobStatus {
+    active?: ObjectReference[];
+    lastScheduleTime: string;
+}
+export interface CronJob extends KubernetesResource {
+    spec?: CronJobSpec;
+    status?: CronJobStatus;
+}
+export type NodeStatusReason = 'KubeletHasSufficientDisk' | 'KubeletHasSufficientMemory' | 'KubeletHasNoDiskPressure' | 'KubeletReady';
+export type NodeStatusType = 'OutOfDisk' | 'MemoryPressure' | 'DiskPressure' | 'Ready';
+export interface NodeTaint {
+    key: string;
+    timeAdded?: string;
+    effect: TaintEffect;
+    value?: string;
+    unschedulable?: boolean;
+}
+export interface Node extends KubernetesResource {
+    spec?: {
+        providerID?: string;
+        taints?: NodeTaint[];
+        configSource?: string;
+        unschedulable?: boolean;
+        podCIDR?: string;
+        podCIDRs?: string[];
+        externalID?: string;
+        ip?: string;
+    };
+    status?: NodeStatus;
+}
+export interface NodeStatus {
+    volumesAttached: boolean;
+    daemonEndpoints: {
+        kubeletEndpoint: {
+            port: number;
+        };
+    };
+    capacity: Record<string, string>;
+    addresses: Array<{
+        type: string;
+        address: string;
+    }>;
+    allocatable: {
+        'alpha.kubernetes.io/nvidia-gpu': string;
+        'tencent.com/vcuda-core': string;
+        'tencent.com/vcuda-memory': string;
+        pods: string;
+        cpu: string;
+        memory: string;
+    };
+    images: Array<{
+        sizeBytes: number;
+        names: string[];
+    }>;
+    nodeInfo: {
+        kubeProxyVersion: string;
+        operatingSystem: string;
+        kernelVersion: string;
+        systemUUID: string;
+        containerRuntimeVersion: string;
+        osImage: string;
+        architecture: string;
+        bootID: string;
+        machineID: string;
+        kubeletVersion: string;
+    };
+    volumesInUse: boolean;
+    phase: string;
+    conditions: Condition[];
+}
+export interface Service extends KubernetesResource {
+    kind: 'Service';
+    spec?: ServiceSpec;
+    status?: {
+        loadBalancer?: {
+            ingress?: Array<{
+                hostname?: string;
+                ip?: string;
+            }>;
+        };
+    };
+}
+export declare const SERVICE_TYPES: readonly ["ClusterIP", "NodePort", "LoadBalancer", "ExternalName"];
+export declare const SERVICE_SESSION_AFFINITIES: readonly ["None", "ClientIP"];
+export type ServiceType = (typeof SERVICE_TYPES)[number];
+export type ServiceSessionAffinity = (typeof SERVICE_SESSION_AFFINITIES)[number];
+export interface ServiceSpec {
+    clusterIP?: string;
+    clusterIPs?: string[];
+    externalIPs?: string[];
+    externalName?: string;
+    ipFamilies?: ['IPv4'] | ['IPv6'] | ['IPv4', 'IPv6'] | ['IPv6', 'IPv4'];
+    ipFamilyPolicy?: 'SingleStack' | 'PreferDualStack' | 'RequireDualStack';
+    ports?: ServicePort[];
+    selector?: StringMap;
+    type?: ServiceType;
+    sessionAffinity?: ServiceSessionAffinity;
+}
+export declare const SERVICE_PORT_BASE_PROTOCOLS: readonly ["TCP", "UDP"];
+export type ServicePortBaseProtocol = (typeof SERVICE_PORT_BASE_PROTOCOLS)[number];
+export declare const SERVICE_PORT_PROTOCOLS: readonly ["TCP", "UDP", "HTTP", "HTTPS", "HTTP2", "gRPC"];
+export type ServicePortProtocol = (typeof SERVICE_PORT_PROTOCOLS)[number];
+export interface ServicePort {
+    name?: string;
+    nodePort?: number;
+    port?: number;
+    protocol?: ServicePortBaseProtocol;
+    appProtocol?: Lowercase<ServicePortProtocol>;
+    targetPort?: number | string;
+}
+export interface CustomResourceDefinitionVersion {
+    name: string;
+    served: boolean;
+    storage: boolean;
+    schema?: {
+        openAPIV3Schema: OpenAPIV3SchemaObject;
+    };
+}
+export interface CustomResourceDefinition extends KubernetesResource {
+    kind: 'CustomResourceDefinition';
+    spec: {
+        group: string;
+        version: string;
+        names: {
+            plural: string;
+            singular: string;
+            kind: string;
+            listKind: string;
+        };
+        scope: string;
+        validation: {
+            openAPIV3Schema: OpenAPIV3SchemaObject;
+        };
+        versions: CustomResourceDefinitionVersion[];
+        preserveUnknownFields: boolean;
+    };
+}
+export interface CleanupRetentionPolicyResourceSpec {
+    controller?: string;
+    storagePluginRef?: {
+        name: string;
+    };
+    enabled?: boolean;
+    rules: RetentionPolicyRule[];
+}
+export interface CleanupRetentionPolicyResource extends KubernetesResource {
+    spec: CleanupRetentionPolicyResourceSpec;
+}
+export interface RetentionPolicyRule {
+    type: string;
+    value: string;
+    regex?: string[];
+}
+export type StoragePluginParams = Array<{
+    name: string;
+    value: string;
+}>;
+export interface storagePluginClass extends KubernetesResource {
+    spec: {
+        controller: string;
+        params: Array<{
+            name: string;
+            type: string;
+        }>;
+    };
+}
+export interface StoragePlugin extends KubernetesResource {
+    spec: {
+        storagePluginClassName: string;
+        params: StoragePluginParams;
+    };
+    status?: {
+        conditions?: Condition[];
+    };
+}
+export interface NameSpaceResourceRatio extends KubernetesResource {
+    spec: {
+        cpu: number;
+        memory: number;
+    };
+    status: {
+        clusterCPU: number;
+        clusterMemory: number;
+    };
+}