/**
 * 此文件只维护 所有的 k8s 原生类型
 */
import { StringMap } from '@alauda/ui';
import { OpenAPIV3SchemaObject } from '../schema';
export interface TypeMeta {
    kind?: string;
    apiVersion?: string;
}
export interface OwnerReference {
    apiVersion: string;
    kind: string;
    name: string;
    uid: string;
    controller?: boolean;
    blockOwnerDeletion?: boolean;
}
export interface ObjectMeta {
    name?: string;
    generateName?: string;
    namespace?: string;
    labels?: StringMap;
    annotations?: StringMap;
    finalizers?: string[];
    selfLink?: string;
    uid?: string;
    creationTimestamp?: string;
    deletionTimestamp?: string;
    ownerReferences?: OwnerReference[];
    resourceVersion?: string;
    generation?: number;
    continue?: string;
    totalItems?: number;
    managedFields?: unknown;
    clusterName?: string;
}
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 KubernetesResource extends TypeMeta {
    metadata?: ObjectMeta;
    status?: unknown;
    spec?: unknown;
}
export interface KubernetesResourceList<T extends KubernetesResource = KubernetesResource> extends KubernetesResource {
    items: T[];
}
export interface LabelSelector {
    matchLabels?: StringMap;
    matchExpressions?: LabelSelectorRequirement[];
}
export interface LabelSelectorRequirement {
    key: string;
    operator?: // eslint-disable-next-line sonar/max-union-size
    '=' | '==' | '!=' | '!' | 'in' | 'notin' | 'exists' | 'doesnotexist';
    values?: 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"
}
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[];
    nodeSelector?: StringMap;
    hostNetwork?: boolean;
    affinity?: Affinity;
    restartPolicy?: string;
    imagePullSecrets?: LocalObjectReference[];
    serviceAccountName?: string;
    serviceAccount?: string;
    nodeName?: string;
    terminationGracePeriodSeconds?: number;
}
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 declare type StatefulSetStatus = Partial<{
    collisionCount: number;
    observedGeneration: number;
    replicas: number;
    readyReplicas: number;
    currentReplicas: number;
    currentRevision: string;
    updateRevision: string;
    updatedReplicas?: number;
}>;
export declare type DeploymentStrategyType = 'RollingUpdate' | 'Recreate';
export declare type DaemonSetUpdateStrategyType = 'RollingUpdate' | 'OnDelete';
export declare 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 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: string[];
    volumeMode?: PersistentVolumeClaimVolumeMode;
}
export declare type PersistentVolumeClaimVolumeMode = 'Filesystem' | 'Block';
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 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;
    };
}
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?: ResourceCondition[];
    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 ResourceCondition {
    lastProbeTime?: string;
    lastTransitionTime?: string;
    message?: string;
    reason?: string;
    status?: string;
    type?: 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?: ResourceCondition[];
}
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[];
    preferredDuringSchedulingIgnoredDuringExecution?: WeightedPodAffinityTerm[];
}
export interface WeightedPodAffinityTerm {
    podAffinityTerm: PodAffinityTerm;
    weight: number;
}
export interface PodAffinityTerm {
    labelSelector: LabelSelector;
    topologyKey: string;
    namespaces?: string[];
}
export declare enum VolumeTypeEnum {
    persistentVolumeClaim = "persistentVolumeClaim",
    csi = "csi",
    configMap = "configMap",
    secret = "secret",
    hostPath = "hostPath",
    emptyDir = "emptyDir"
}
export interface Volume {
    name: string;
    [VolumeTypeEnum.emptyDir]?: EmptyDirVolumeSource;
    [VolumeTypeEnum.configMap]?: ConfigMapVolumeSource;
    [VolumeTypeEnum.secret]?: SecretVolumeSource;
    [VolumeTypeEnum.persistentVolumeClaim]?: PersistentVolumeClaimVolumeSource;
    [VolumeTypeEnum.hostPath]?: HostPathVolumeSource;
    [VolumeTypeEnum.csi]?: CsiVolumeSource;
    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 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 declare 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 declare 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;
    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: ResourceCondition[];
    startTime: string;
    succeeded: number;
    failed: number;
}
export interface ObjectReference {
    apiVersion: string;
    fieldPath: string;
    kind: string;
    name: string;
    namespace: string;
    resourceVersion: string;
    uid: string;
}
export interface CronJobStatus {
    active?: ObjectReference[];
    lastScheduleTime: string;
}
export interface CronJob extends KubernetesResource {
    spec?: CronJobSpec;
    status?: CronJobStatus;
}
export declare type NodeStatusReason = 'KubeletHasSufficientDisk' | 'KubeletHasSufficientMemory' | 'KubeletHasNoDiskPressure' | 'KubeletReady';
export declare type NodeStatusType = 'OutOfDisk' | 'MemoryPressure' | 'DiskPressure' | 'Ready';
export interface NodeStatus {
    volumesAttached: boolean;
    daemonEndpoints: {
        kubeletEndpoint: {
            port: number;
        };
    };
    capacity: {
        'alpha.kubernetes.io/nvidia-gpu': string;
        'tencent.com/vcuda-core': string;
        'tencent.com/vcuda-memory': string;
        'nvidia.com/gpu': string;
        pods: string;
        cpu: string;
        memory: 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: ResourceCondition[];
}
export interface Service extends KubernetesResource {
    kind: 'Service';
    spec?: ServiceSpec;
    status?: {
        loadBalancer?: {
            ingress?: Array<{
                ip?: string;
            }>;
        };
    };
}
export declare const SERVICE_TYPES: readonly ["ClusterIP", "NodePort", "LoadBalancer", "ExternalName"];
export declare const SERVICE_SESSION_AFFINITIES: readonly ["None", "ClientIP"];
export declare const EXTERNAL_ACCESS_OPTIONS: readonly ["ClusterIP", "NodePort", "LoadBalancer"];
export declare const NON_LB_EXTERNAL_ACCESS_OPTIONS: ("ClusterIP" | "NodePort" | "LoadBalancer")[];
export declare type ServiceType = typeof SERVICE_TYPES[number];
export declare 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 declare type ServicePortBaseProtocol = typeof SERVICE_PORT_BASE_PROTOCOLS[number];
export declare const SERVICE_PORT_PROTOCOLS: readonly ["TCP", "UDP", "HTTP", "HTTPS", "HTTP2", "gRPC"];
export declare 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;
    };
}
