kubernetes.km

karmem api;

struct ManagedFieldData table {
    ApiVersion []char;

    FieldsType []char;

    Manager []char;

    Operation []char;

    Subresource []char;

    Time []char;
}

struct ManagedField inline {
    Data ManagedFieldData;
}

struct OwnerReferenceData table {
    ApiVersion []char;

    BlockOwnerDeletion bool;

    Controller bool;

    Kind []char;

    Name []char;

    Uid []char;
}

struct OwnerReference inline {
    Data OwnerReferenceData;
}

struct String inline {
    Value []char;
}

struct MapEntry inline {
    Name []char;
    Value []char;
}

struct Map inline {
    Entries []MapEntry;
}

struct ObjectMeta table {
    Annotations Map;

    CreationTimestamp []char;

    DeletionGracePeriodSeconds int64;

    DeletionTimestamp []char;

    Finalizers []String;

    GenerateName []char;

    Generation int64;

    Labels Map;

    ManagedFields []ManagedField;

    Name []char;

    Namespace []char;

    OwnerReferences []OwnerReference;

    ResourceVersion []char;

    SelfLink []char;

    Uid []char;
}

struct NodeSelectorRequirementData table {
    Key []char;

    Operator []char;

    Values []String;
}

struct NodeSelectorRequirement inline {
    Data NodeSelectorRequirementData;
}

struct NodeSelectorTermData table {
    MatchExpressions []NodeSelectorRequirement;

    MatchFields []NodeSelectorRequirement;
}

struct NodeSelectorTerm inline {
    Data NodeSelectorTermData;
}

struct PreferredSchedulingTermData table {
    Preference NodeSelectorTermData;

    Weight int32;
}

struct PreferredSchedulingTerm inline {
    Data PreferredSchedulingTermData;
}

struct NodeSelector table {
    NodeSelectorTerms []NodeSelectorTerm;
}

struct NodeAffinity table {
    PreferredDuringSchedulingIgnoredDuringExecution []PreferredSchedulingTerm;

    RequiredDuringSchedulingIgnoredDuringExecution NodeSelector;
}

struct LabelSelectorRequirement table {
    Key []char;

    Operator []char;

    Values []String;
}

struct LabelSelector table {
    MatchExpressions LabelSelectorRequirement;

    MatchLabels Map;
}

struct PodAffinityTermData table {
    LabelSelector LabelSelector;

    NamespaceSelector LabelSelector;

    Namespaces []String;

    TopologyKey []char;
}

struct PodAffinityTerm inline {
    Data PodAffinityTermData;
}

struct WeightedPodAffinityTermData table {
    PodAffinityTerm PodAffinityTermData;

    Weight int32;
}

struct WeightedPodAffinityTerm inline {
    Data WeightedPodAffinityTermData;
}

struct PodAffinity table {
    PreferredDuringSchedulingIgnoredDuringExecution []WeightedPodAffinityTerm;

    RequiredDuringSchedulingIgnoredDuringExecution []PodAffinityTerm;
}

struct PodAntiAffinity table {
    PreferredDuringSchedulingIgnoredDuringExecution []WeightedPodAffinityTerm;

    RequiredDuringSchedulingIgnoredDuringExecution []PodAffinityTerm;
}

struct Affinity table {
    NodeAffinity NodeAffinity;

    PodAffinity PodAffinity;

    PodAntiAffinity PodAntiAffinity;
}


struct ConfigMapKeySelector table {
    Key []char;

    Name []char;

    Optional bool;
}

struct ObjectFieldSelector table {
    ApiVersion []char;

    FieldPath []char;
}

struct ResourceFieldSelector table {
    ContainerName []char;

    Divisor []char;

    Resource []char;
}

struct SecretKeySelector table {
    Key []char;

    Name []char;

    Optional bool;
}

struct EnvVarSource table {
    ConfigMapKeyRef ConfigMapKeySelector;

    FieldRef ObjectFieldSelector;

    ResourceFieldRef ResourceFieldSelector;

    SecretKeyRef SecretKeySelector;
}

struct EnvVarData table {
    Name []char;

    Value []char;

    ValueFrom EnvVarSource;
}

struct EnvVar inline {
    Data EnvVarData;
}

struct ConfigMapEnvSource table {
    Name []char;

    Optional bool;
}

struct SecretEnvSource table {
    Name []char;

    Optional bool;
}

struct EnvFromSourceData table {
    ConfigMapRef ConfigMapEnvSource;

    Prefix []char;

    SecretRef SecretEnvSource;
}

struct EnvFromSource inline {
    Data EnvFromSourceData;
}

struct ExecAction table {
    Command []String;
}

struct HTTPHeader inline {
    Name []char;
    Value []char;
}

struct HTTPGetAction table {
    Host []char;

    HttpHeaders []HTTPHeader;

    Path []char;

    Port []char;

    Scheme []char;
}

struct TCPSocketAction table {
    Host []char;

    Port []char;
}

struct LifecycleHandler table {
    Exec ExecAction;

    HttpGet HTTPGetAction;

    TcpSocket TCPSocketAction;
}

struct Lifecycle table {
    PostStart LifecycleHandler;

    PreStop LifecycleHandler;
}

struct GRPCAction table {
    Port int32;

    Service []char;
}

struct Probe table {
    Exec ExecAction;

    FailureThreshold int32;

    Grpc GRPCAction;

    HttpGet HTTPGetAction;

    InitialDelaySeconds int32;

    PeriodSeconds int32;

    SuccessThreshold int32;

    TcpSocket TCPSocketAction;

    TerminationGracePeriodSeconds int64;

    TimeoutSeconds int32;
}

struct ContainerPortData table {
    ContainerPort int32;

    HostIP []char;

    HostPort int32;

    Name []char;

    Protocol []char;
}

struct ContainerPort inline {
    Data ContainerPortData;
}

struct ContainerResizePolicyData table {
    ResourceName []char;

    RestartPolicy []char;
}

struct ContainerResizePolicy inline {
    Data ContainerResizePolicyData;
}

struct ResourceClaimData table {
    Name []char;
}

struct ResourceClaim inline {
    Data ResourceClaimData;
}

struct ResourceRequirements table {
    Claims []ResourceClaim;

    Limits Map;

    Requests Map;
}

struct Capabilities table {
    Add []String;

    Drop []String;
}

struct SELinuxOptions table {
    Level []char;

    Role []char;

    Type []char;

    User []char;
}

struct SeccompProfile table {
    LocalhostProfile []char;

    Type []char;
}

struct WindowsSecurityContextOptions table {
    GmsaCredentialSpec []char;

    GmsaCredentialSpecName []char;

    HostProcess bool;

    RunAsUserName []char;
}

struct SecurityContext table {
    AllowPrivilegeEscalation bool;

    Capabilities Capabilities;

    Privileged bool;

    ProcMount []char;

    ReadOnlyRootFilesystem bool;

    RunAsGroup int64;

    RunAsNonRoot bool;

    RunAsUser int64;

    SeLinuxOptions SELinuxOptions;

    SeccompProfile SeccompProfile;

    WindowsOptions WindowsSecurityContextOptions;
}

struct VolumeDeviceData table {
    DevicePath []char;

    Name []char;
}

struct VolumeDevice inline {
    Data VolumeDeviceData;
}

struct VolumeMountData table {
    MountPath []char;

    MountPropagation []char;

    Name []char;

    ReadOnly bool;

    SubPath []char;

    SubPathExpr []char;
}

struct VolumeMount inline {
    Data VolumeMountData;
}

struct ContainerData table {
    Args []String;

    Command []String;

    Env []EnvVar;

    EnvFrom []EnvFromSource;

    Image []char;

    ImagePullPolicy []char;

    Lifecycle Lifecycle;

    LivenessProbe Probe;

    Name []char;

    Ports []ContainerPort;

    ReadinessProbe Probe;

    ResizePolicy []ContainerResizePolicy;

    Resources ResourceRequirements;

    SecurityContext SecurityContext;

    StartupProbe Probe;

    Stdin bool;

    StdinOnce bool;

    TerminationMessagePath []char;

    TerminationMessagePolicy []char;

    Tty bool;

    VolumeDevices []VolumeDevice;

    VolumeMounts []VolumeMount;

    WorkingDir []char;
}

struct Container inline {
    Data ContainerData;
}

struct PodDNSConfigOptionData table {
    Name []char;
    Value []char;
}

struct PodDNSConfigOption inline {
    Data PodDNSConfigOptionData;
}

struct PodDNSConfig table {
    Nameservers []String;

    Options []PodDNSConfigOption;

    Searches []String;
}

struct EphemeralContainerData table {
    Args []String;

    Command []String;

    Env []EnvVar;

    EnvFrom []EnvFromSource;

    Image []char;

    ImagePullPolicy []char;

    Lifecycle Lifecycle;

    LivenessProbe Probe;

    Name []char;

    Ports []ContainerPort;

    ReadinessProbe Probe;

    ResizePolicy []ContainerResizePolicy;

    Resources ResourceRequirements;

    SecurityContext SecurityContext;

    StartupProbe Probe;

    Stdin bool;

    StdinOnce bool;

    TargetContainerName []char;

    TerminationMessagePath []char;

    TerminationMessagePolicy []char;

    Tty bool;

    VolumeDevices []VolumeDevice;

    VolumeMounts VolumeMount;

    WorkingDir []char;
}

struct EphemeralContainer inline {
    Data EphemeralContainerData;
}

struct HostAliasData table {
    Hostnames []String;

    Ip []char;
}

struct HostAlias inline {
    Data HostAliasData;
}

struct LocalObjectReferenceData table {
    Name []char;
}

struct LocalObjectReference inline {
    Data LocalObjectReferenceData;
}

struct PodOS table {
    Name []char;
}

struct PodReadinessGateData table {
    ConditionType []char;
}

struct PodReadinessGate inline {
    Data PodReadinessGateData;
}

struct ClaimSource table {
    ResourceClaimName []char;

    ResourceClaimTemplateName []char;
}

struct PodResourceClaimData table {
    Name []char;

    Source ClaimSource;
}

struct PodResourceClaim inline {
    Data PodResourceClaimData;
}

struct PodSchedulingGateData table {
    Name []char;
}

struct PodSchedulingGate inline {
    Data PodSchedulingGateData;
}

struct SysctlData table {
    Name []char;

    Value []char;
}

struct Sysctl inline {
    Data SysctlData;
}

struct PodSecurityContext table {
    FsGroup int64;

    FsGroupChangePolicy []char;

    RunAsGroup int64;

    RunAsNonRoot bool;

    RunAsUser int64;

    SeLinuxOptions SELinuxOptions;

    SeccompProfile SeccompProfile;

    SupplementalGroups []int64;

    Sysctls []Sysctl;

    WindowsOptions WindowsSecurityContextOptions;
}

struct TolerationData table {
    Effect []char;

    Key []char;

    Operator []char;

    TolerationSeconds int64;

    Value []char;
}

struct Toleration inline {
    Data TolerationData;
}

struct TopologySpreadConstraintData table {
    LabelSelector LabelSelector;

    MatchLabelKeys []String;

    MaxSkew int32;

    MinDomains int32;

    NodeAffinityPolicy []char;

    NodeTaintsPolicy []char;

    TopologyKey []char;

    WhenUnsatisfiable []char;
}

struct TopologySpreadConstraint inline {
    Data TopologySpreadConstraintData;
}

struct AWSElasticBlockStoreVolumeSource table {
    FsType []char;

    Partition int32;

    ReadOnly bool;

    VolumeID []char;
}

struct AzureDiskVolumeSource table {
    CachingMode []char;

    DiskName []char;

    DiskURI []char;

    FsType []char;

    Kind []char;

    ReadOnly bool;
}

struct AzureFileVolumeSource table {
    ReadOnly bool;

    SecretName []char;

    ShareName []char;
}

struct CephFSVolumeSource table {
    Monitors []String;

    Path []char;

    ReadOnly bool;

    SecretFile []char;

    SecretRef LocalObjectReferenceData;

    User []char;
}

struct CinderVolumeSource table {
    FsType []char;

    ReadOnly bool;

    SecretRef LocalObjectReferenceData;

    VolumeID []char;
}

struct KeyToPathData table {
    Key []char;

    Mode int32;

    Path []char;
}

struct KeyToPath inline {
    Data KeyToPathData;
}

struct ConfigMapVolumeSource table {
    DefaultMode int32;

    Items []KeyToPath;

    Name []char;

    Optional bool;
}

struct CSIVolumeSource table {
    Driver []char;

    FsType []char;

    NodePublishSecretRef LocalObjectReferenceData;

    ReadOnly bool;

    VolumeAttributes Map;
}

struct DownwardAPIVolumeFileData table {
    FieldRef ObjectFieldSelector;

    Mode int32;

    Path []char;

    ResourceFieldRef ResourceFieldSelector;
}

struct DownwardAPIVolumeFile inline {
    Data DownwardAPIVolumeFileData;
}

struct DownwardAPIVolumeSource table {
    DefaultMode int32;

    Items []DownwardAPIVolumeFile;
}

struct EmptyDirVolumeSource table {
    Medium []char;

    SizeLimit []char;
}

struct TypedLocalObjectReference table {
    ApiGroup []char;

    Kind []char;

    Name []char;
}

struct TypedObjectReference table {
    ApiGroup []char;

    Kind []char;

    Name []char;

    Mamespace []char;
}

struct PersistentVolumeClaimSpec table {
    AccessModes []String;

    DataSource TypedLocalObjectReference;

    DataSourceRef TypedObjectReference;

    Resources ResourceRequirements;

    Selector LabelSelector;

    StorageClassName []char;

    VolumeMode []char;

    VolumeName []char;
}

struct PersistentVolumeClaimTemplate table {
    Metadata ObjectMeta;

    Spec PersistentVolumeClaimSpec;
}

struct EphemeralVolumeSource table {
    VolumeClaimTemplate PersistentVolumeClaimTemplate;
}

struct FCVolumeSource table {
    FsType []char;

    Lun int32;

    ReadOnly bool;

    TargetWWNs []String;

    Wwids []String;
}

struct FlexVolumeSource table {
    Driver []char;

    FsType []char;

    Options Map;

    ReadOnly bool;

    SecretRef LocalObjectReferenceData;
}

struct FlockerVolumeSource table {
    DatasetName []char;

    DatasetUUID []char;
}

struct GCEPersistentDiskVolumeSource table {
    FsType []char;

    Partition int32;

    PdName []char;

    ReadOnly bool;
}

struct GitRepoVolumeSource table {
    Directory []char;

    Repository []char;

    Revision []char;
}

struct GlusterfsVolumeSource table {
    Endpoints []char;

    Path []char;

    ReadOnly bool;
}

struct HostPathVolumeSource table {
    Path []char;

    Type []char;
}

struct ISCSIVolumeSource table {
    ChapAuthDiscovery bool;

    ChapAuthSession bool;

    FsType []char;

    InitiatorName []char;

    Iqn []char;

    IscsiInterface []char;

    Lun int32;

    Portals []String;

    ReadOnly bool;

    SecretRef LocalObjectReferenceData;

    TargetPortal []char;
}

struct NFSVolumeSource table {
    Path []char;

    ReadOnly bool;

    Server []char;
}

struct PersistentVolumeClaimVolumeSource table {
    ClaimName []char;

    ReadOnly bool;
}

struct PhotonPersistentDiskVolumeSource table {
    FsType []char;

    PdID []char;
}

struct PortworxVolumeSource table {
    FsType []char;

    ReadOnly bool;

    VolumeID []char;
}

struct ConfigMapProjection table {
    Items []KeyToPath;

    Name []char;

    Optional bool;
}

struct DownwardAPIProjection table {
    Items []DownwardAPIVolumeFile;
}

struct SecretProjection table {
    Items []KeyToPath;

    Name []char;

    Optional bool;
}

struct ServiceAccountTokenProjection table {
    Audience []char;

    ExpirationSeconds int64;

    Path []char;
}

struct VolumeProjectionData table {
    ConfigMap ConfigMapProjection;

    DownwardAPI DownwardAPIProjection;

    Secret SecretProjection;

    ServiceAccountToken ServiceAccountTokenProjection;
}

struct VolumeProjection inline {
    Data VolumeProjectionData;
}

struct ProjectedVolumeSource table {
    DefaultMode int32;

    Sources []VolumeProjection;
}

struct QuobyteVolumeSource table {
    Group []char;

    ReadOnly bool;

    Registry []char;

    Tenant []char;

    User []char;

    Volume []char;
}

struct RBDVolumeSource table {
    FsType []char;

    Image []char;

    Keyring []char;

    Monitors []String;

    Pool []char;

    ReadOnly bool;

    SecretRef LocalObjectReferenceData;

    User []char;
}

struct ScaleIOVolumeSource table {
    FsType []char;

    Gateway []char;

    ProtectionDomain []char;

    ReadOnly bool;

    SecretRef LocalObjectReferenceData;

    SslEnabled bool;

    StorageMode []char;

    StoragePool []char;

    System []char;

    VolumeName []char;
}

struct SecretVolumeSource table {
    DefaultMode int32;

    Items []KeyToPath;

    Optional bool;

    SecretName []char;
}

struct StorageOSVolumeSource table {
    FsType []char;

    ReadOnly bool;

    SecretRef LocalObjectReferenceData;

    VolumeName []char;

    VolumeNamespace []char;
}

struct VsphereVirtualDiskVolumeSource table {
    FsType []char;

    StoragePolicyID []char;

    StoragePolicyName []char;

    VolumePath []char;
}

struct VolumeData table {
    AwsElasticBlockStore AWSElasticBlockStoreVolumeSource;

    AzureDisk AzureDiskVolumeSource;

    AzureFile AzureFileVolumeSource;

    Cephfs CephFSVolumeSource;

    Cinder CinderVolumeSource;

    ConfigMap ConfigMapVolumeSource;

    Csi CSIVolumeSource;

    DownwardAPI DownwardAPIVolumeSource;

    EmptyDir EmptyDirVolumeSource;

    Ephemeral EphemeralVolumeSource;

    Fc FCVolumeSource;

    FlexVolume FlexVolumeSource;

    Flocker FlockerVolumeSource;

    GcePersistentDisk GCEPersistentDiskVolumeSource;

    GitRepo GitRepoVolumeSource;

    Glusterfs GlusterfsVolumeSource;

    HostPath HostPathVolumeSource;

    Iscsi ISCSIVolumeSource;

    Name []char;

    Nfs NFSVolumeSource;

    PersistentVolumeClaim PersistentVolumeClaimVolumeSource;

    PhotonPersistentDisk PhotonPersistentDiskVolumeSource;

    PortworxVolume PortworxVolumeSource;

    Projected ProjectedVolumeSource;

    Quobyte QuobyteVolumeSource;

    Rbd RBDVolumeSource;

    ScaleIO ScaleIOVolumeSource;

    Secret SecretVolumeSource;

    Storageos StorageOSVolumeSource;

    VsphereVolume VsphereVirtualDiskVolumeSource;
}

struct Volume inline {
    Data VolumeData;
}

struct PodSpec table {
    ActiveDeadlineSeconds int64;

    Affinity Affinity;

    AutomountServiceAccountToken bool;

    Containers []Container;

    DnsConfig PodDNSConfig;

    DnsPolicy []char;

    EnableServiceLinks []char;

    EphemeralContainers []EphemeralContainer;

    HostAliases []HostAlias;

    HostIPC bool;

    HostNetwork bool;

    HostPID bool;

    HostUsers bool;

    Hostname []char;

    ImagePullSecrets []LocalObjectReference;

    InitContainers []Container;

    NodeName []char;

    NodeSelector Map;

    Os PodOS;

    Overhead Map;

    PreemptionPolicy []char;

    Priority int32;

    PriorityClassName []char;

    ReadinessGates []PodReadinessGate;

    ResourceClaims []PodResourceClaim;

    RestartPolicy []char;

    RuntimeClassName []char;

    SchedulerName []char;

    SchedulingGates []PodSchedulingGate;

    SecurityContext PodSecurityContext;

    ServiceAccount []char;

    ServiceAccountName []char;

    SetHostnameAsFQDN bool;

    ShareProcessNamespace bool;

    Subdomain []char;

    TerminationGracePeriodSeconds int64;

    Tolerations []Toleration;

    TopologySpreadConstraints []TopologySpreadConstraint;

    Volumes []Volume;
}

struct PodConditionData table {
    LastProbeTime []char;

    LastTransitionTime []char;

    Message []char;

    Reason []char;

    Status []char;

    Type []char;
}

struct PodCondition inline {
    Data PodConditionData;
}

struct ContainerStateRunning table {
    StartedAt []char;
}

struct ContainerStateTerminated table {
    ContainerID []char;

    ExitCode int32;

    FinishedAt []char;

    Message []char;

    Reason []char;

    Signal int32;

    StartedAt []char;
}

struct ContainerStateWaiting table {
    Message []char;

    Reason []char;
}

struct ContainerState table {
    Running ContainerStateRunning;

    Terminated ContainerStateTerminated;

    Waiting ContainerStateWaiting;
}

struct ContainerStatusData table {
    AllocatedResources Map;

    ContainerID []char;

    Image []char;

    ImageID []char;

    LastState ContainerState;

    Name []char;

    Ready bool;

    Resources ResourceRequirements;

    RestartCount int32;

    Started bool;

    State ContainerState;
}

struct ContainerStatus inline {
    Data ContainerStatusData;
}

struct PodIPData table {
    Ip []char;
}

struct PodIP inline {
    Data PodIPData;
}

struct PodStatus table {
    Conditions []PodCondition;

    ContainerStatuses []ContainerStatus;

    EphemeralContainerStatuses []ContainerStatus;

    HostIP []char;

    InitContainerStatuses []ContainerStatus;

    Message []char;

    NominatedNodeName []char;

    Phase []char;

    PodIP []char;

    PodIPs []PodIP;

    QosClass []char;

    Reason []char;

    Resize []char;

    StartTime []char;
}

struct Pod table {
    ApiVersion []char;

    Kind []char;

    Metadata ObjectMeta;

    Spec PodSpec;

    Status PodStatus;
}

struct TaintData table {
    Effect []char;

    Key []char;

    TimeAdded []char;

    Value []char;
}

struct Taint inline {
    Data TaintData;
}

struct NodeSpec table {
    PodCIDR []char;

    PodCIDRs []String;

    ProviderID []char;

    Taints []Taint;

    Unschedulable bool;
}

struct NodeAddressData table {
    Address []char;

    Type []char;
}

struct NodeAddress inline {
    Data NodeAddressData;
}

struct NodeConditionData table {
    LastHeartbeatTime []char;

    LastTransitionTime []char;

    Message []char;

    Reason []char;

    Status []char;

    Type []char;
}

struct NodeCondition inline {
    Data NodeConditionData;
}

struct ConfigMapNodeConfigSource table {
    KubeletConfigKey []char;

    Name []char;

    Namespace []char;

    ResourceVersion []char;

    Uid []char;
}

struct NodeConfigSource table {
    ConfigMap ConfigMapNodeConfigSource;
}

struct NodeConfigStatus table {
    Active NodeConfigSource;

    Assigned NodeConfigSource;

    Error []char;

    LastKnownGood NodeConfigSource;
}

struct DaemonEndpoint table {
    Port int32;
}

struct NodeDaemonEndpoints table {
    KubeletEndpoint DaemonEndpoint;
}

struct ContainerImageData table {
    Names []String;

    SizeBytes int64;
}

struct ContainerImage inline {
    Data ContainerImageData;
}

struct NodeSystemInfo table {
    Architecture []char;

    BootID []char;

    ContainerRuntimeVersion []char;

    KernelVersion []char;

    KubeProxyVersion []char;

    KubeletVersion []char;

    MachineID []char;

    OperatingSystem []char;

    OsImage []char;

    SystemUUID []char;
}

struct AttachedVolumeData table {
    DevicePath []char;

    Name []char;
}

struct AttachedVolume inline {
    Data AttachedVolumeData;
}

struct NodeStatus table {
    Addresses []NodeAddress;

    Allocatable Map;

    Capacity Map;

    Conditions []NodeCondition;

    Config NodeConfigStatus;

    DaemonEndpoints NodeDaemonEndpoints;

    Images []ContainerImage;

    NodeInfo NodeSystemInfo;

    Phase []char;

    VolumesAttached []AttachedVolume;

    VolumesInUse []String;
}

struct Node table {
    ApiVersion []char;

    Kind []char;

    Metadata ObjectMeta;

    Spec NodeSpec;

    Status NodeStatus;
}

struct PodInfoData table {
	Pod Pod;
	RequiredAffinityTerms      []PodAffinityTerm;
	RequiredAntiAffinityTerms  []PodAffinityTerm;
	PreferredAffinityTerms     []WeightedPodAffinityTerm;
	PreferredAntiAffinityTerms []WeightedPodAffinityTerm;
}

struct PodInfo inline {
    Data PodInfoData;
}

struct Int64MapEntry inline {
    Name []char;
    Value int64;
}

struct Int64Map inline {
    Entries []Int64MapEntry;
}

struct ProtocolPortData table {
	Protocol []char;
	Port     int32;
}

struct ProtocolPort inline {
    Data ProtocolPortData;
}

struct ProtocolPortEntry inline {
    Name []char;
    Value []ProtocolPort;
}

struct HostPortInfo inline {
    Entries []ProtocolPortEntry;
}

struct Resource table {
	MilliCPU         int64;
	Memory           int64;
	EphemeralStorage int64;
	AllowedPodNumber int64;
	ScalarResources  Int64Map;
}

struct ImageState table {
	Size int64;
	NumNodes int64;
}

struct ImageStateMapEntry inline {
    Name []char;
    Value ImageState;
}

struct ImageStateMap inline {
    Entries []ImageStateMapEntry;
}

struct NodeInfo table {
	Node Node;

	Pods []PodInfo;

	PodsWithAffinity []PodInfo;

	PodsWithRequiredAntiAffinity []PodInfo;

	UsedPorts HostPortInfo;

	Requested Resource;

	NonZeroRequested Resource;

	Allocatable Resource;

	ImageStates ImageStateMap;

	PVCRefCounts Int64Map;

	Generation int64;
}