import { Resource } from '@c6o/kubeclient-contracts';
import { Condition, LabelSelector, ListMeta, MicroTime, ObjectMeta, Time } from '../meta/v1';
import { Quantity } from '../api/resource';
export interface AWSElasticBlockStoreVolumeSource {
    fsType?: string;
    partition?: number;
    readOnly?: boolean;
    volumeID: string;
}
export interface Affinity {
    nodeAffinity?: NodeAffinity;
    podAffinity?: PodAffinity;
    podAntiAffinity?: PodAntiAffinity;
}
export interface AttachedVolume {
    devicePath: string;
    name: string;
}
export interface AzureDiskVolumeSource {
    cachingMode?: string;
    diskName: string;
    diskURI: string;
    fsType?: string;
    kind?: string;
    readOnly?: boolean;
}
export interface AzureFilePersistentVolumeSource {
    readOnly?: boolean;
    secretName: string;
    secretNamespace?: string;
    shareName: string;
}
export interface AzureFileVolumeSource {
    readOnly?: boolean;
    secretName: string;
    shareName: string;
}
export interface Binding extends Resource {
    apiVersion?: 'v1';
    kind?: 'Binding';
    metadata?: ObjectMeta;
    target: ObjectReference;
}
export interface CSIPersistentVolumeSource {
    controllerExpandSecretRef?: SecretReference;
    controllerPublishSecretRef?: SecretReference;
    driver: string;
    fsType?: string;
    nodePublishSecretRef?: SecretReference;
    nodeStageSecretRef?: SecretReference;
    readOnly?: boolean;
    volumeAttributes?: {
        [name: string]: string;
    };
    volumeHandle: string;
}
export interface CSIVolumeSource {
    driver: string;
    fsType?: string;
    nodePublishSecretRef?: LocalObjectReference;
    readOnly?: boolean;
    volumeAttributes?: {
        [name: string]: string;
    };
}
export interface Capabilities {
    add?: Array<string>;
    drop?: Array<string>;
}
export interface CephFSPersistentVolumeSource {
    monitors: Array<string>;
    path?: string;
    readOnly?: boolean;
    secretFile?: string;
    secretRef?: SecretReference;
    user?: string;
}
export interface CephFSVolumeSource {
    monitors: Array<string>;
    path?: string;
    readOnly?: boolean;
    secretFile?: string;
    secretRef?: LocalObjectReference;
    user?: string;
}
export interface CinderPersistentVolumeSource {
    fsType?: string;
    readOnly?: boolean;
    secretRef?: SecretReference;
    volumeID: string;
}
export interface CinderVolumeSource {
    fsType?: string;
    readOnly?: boolean;
    secretRef?: LocalObjectReference;
    volumeID: string;
}
export interface ClientIPConfig {
    timeoutSeconds?: number;
}
export interface ComponentCondition {
    error?: string;
    message?: string;
    status: string;
    type: string;
}
export interface ComponentStatus extends Resource {
    apiVersion?: 'v1';
    conditions?: Array<ComponentCondition>;
    kind?: 'ComponentStatus';
    metadata?: ObjectMeta;
}
export interface ComponentStatusList extends Resource {
    apiVersion?: 'v1';
    items: Array<ComponentStatus>;
    kind?: 'ComponentStatusList';
    metadata?: ListMeta;
}
export interface ConfigMap extends Resource {
    apiVersion?: 'v1';
    binaryData?: {
        [name: string]: string;
    };
    data?: {
        [name: string]: string;
    };
    immutable?: boolean;
    kind?: 'ConfigMap';
    metadata?: ObjectMeta;
}
export interface ConfigMapEnvSource {
    name?: string;
    optional?: boolean;
}
export interface ConfigMapKeySelector {
    key: string;
    name?: string;
    optional?: boolean;
}
export interface ConfigMapList extends Resource {
    apiVersion?: 'v1';
    items: Array<ConfigMap>;
    kind?: 'ConfigMapList';
    metadata?: ListMeta;
}
export interface ConfigMapNodeConfigSource {
    kubeletConfigKey: string;
    name: string;
    namespace: string;
    resourceVersion?: string;
    uid?: string;
}
export interface ConfigMapProjection {
    items?: Array<KeyToPath>;
    name?: string;
    optional?: boolean;
}
export interface ConfigMapVolumeSource {
    defaultMode?: number;
    items?: Array<KeyToPath>;
    name?: string;
    optional?: boolean;
}
export interface Container {
    args?: Array<string>;
    command?: Array<string>;
    env?: Array<EnvVar>;
    envFrom?: Array<EnvFromSource>;
    image?: string;
    imagePullPolicy?: string;
    lifecycle?: Lifecycle;
    livenessProbe?: Probe;
    name: string;
    ports?: Array<ContainerPort>;
    readinessProbe?: Probe;
    resources?: ResourceRequirements;
    securityContext?: SecurityContext;
    startupProbe?: Probe;
    stdin?: boolean;
    stdinOnce?: boolean;
    terminationMessagePath?: string;
    terminationMessagePolicy?: string;
    tty?: boolean;
    volumeDevices?: Array<VolumeDevice>;
    volumeMounts?: Array<VolumeMount>;
    workingDir?: string;
}
export interface ContainerImage {
    names: Array<string>;
    sizeBytes?: number;
}
export interface ContainerPort {
    containerPort: number;
    hostIP?: string;
    hostPort?: number;
    name?: string;
    protocol?: string;
}
export interface ContainerState {
    running?: ContainerStateRunning;
    terminated?: ContainerStateTerminated;
    waiting?: ContainerStateWaiting;
}
export interface ContainerStateRunning {
    startedAt?: Time;
}
export interface ContainerStateTerminated {
    containerID?: string;
    exitCode: number;
    finishedAt?: Time;
    message?: string;
    reason?: string;
    signal?: number;
    startedAt?: Time;
}
export interface ContainerStateWaiting {
    message?: string;
    reason?: string;
}
export interface ContainerStatus {
    containerID?: string;
    image: string;
    imageID: string;
    lastState?: ContainerState;
    name: string;
    ready: boolean;
    restartCount: number;
    started?: boolean;
    state?: ContainerState;
}
export interface DaemonEndpoint {
    Port: number;
}
export interface DownwardAPIProjection {
    items?: Array<DownwardAPIVolumeFile>;
}
export interface DownwardAPIVolumeFile {
    fieldRef?: ObjectFieldSelector;
    mode?: number;
    path: string;
    resourceFieldRef?: ResourceFieldSelector;
}
export interface DownwardAPIVolumeSource {
    defaultMode?: number;
    items?: Array<DownwardAPIVolumeFile>;
}
export interface EmptyDirVolumeSource {
    medium?: string;
    sizeLimit?: Quantity;
}
export interface EndpointAddress {
    hostname?: string;
    ip: string;
    nodeName?: string;
    targetRef?: ObjectReference;
}
export interface EndpointPort {
    appProtocol?: string;
    name?: string;
    port: number;
    protocol?: string;
}
export interface EndpointSubset {
    addresses?: Array<EndpointAddress>;
    notReadyAddresses?: Array<EndpointAddress>;
    ports?: Array<EndpointPort>;
}
export interface Endpoints extends Resource {
    apiVersion?: 'v1';
    kind?: 'Endpoints';
    metadata?: ObjectMeta;
    subsets?: Array<EndpointSubset>;
}
export interface EndpointsList extends Resource {
    apiVersion?: 'v1';
    items: Array<Endpoints>;
    kind?: 'EndpointsList';
    metadata?: ListMeta;
}
export interface EnvFromSource {
    configMapRef?: ConfigMapEnvSource;
    prefix?: string;
    secretRef?: SecretEnvSource;
}
export interface EnvVar {
    name: string;
    value?: string;
    valueFrom?: EnvVarSource;
}
export interface EnvVarSource {
    configMapKeyRef?: ConfigMapKeySelector;
    fieldRef?: ObjectFieldSelector;
    resourceFieldRef?: ResourceFieldSelector;
    secretKeyRef?: SecretKeySelector;
}
export interface EphemeralContainer {
    args?: Array<string>;
    command?: Array<string>;
    env?: Array<EnvVar>;
    envFrom?: Array<EnvFromSource>;
    image?: string;
    imagePullPolicy?: string;
    lifecycle?: Lifecycle;
    livenessProbe?: Probe;
    name: string;
    ports?: Array<ContainerPort>;
    readinessProbe?: Probe;
    resources?: ResourceRequirements;
    securityContext?: SecurityContext;
    startupProbe?: Probe;
    stdin?: boolean;
    stdinOnce?: boolean;
    targetContainerName?: string;
    terminationMessagePath?: string;
    terminationMessagePolicy?: string;
    tty?: boolean;
    volumeDevices?: Array<VolumeDevice>;
    volumeMounts?: Array<VolumeMount>;
    workingDir?: string;
}
export interface EphemeralContainers extends Resource {
    apiVersion?: 'v1';
    ephemeralContainers: Array<EphemeralContainer>;
    kind?: 'EphemeralContainers';
    metadata?: ObjectMeta;
}
export interface EphemeralVolumeSource {
    volumeClaimTemplate?: PersistentVolumeClaimTemplate;
}
export interface Event extends Resource {
    action?: string;
    apiVersion?: 'v1';
    count?: number;
    eventTime?: MicroTime;
    firstTimestamp?: Time;
    involvedObject: ObjectReference;
    kind?: 'Event';
    lastTimestamp?: Time;
    message?: string;
    metadata: ObjectMeta;
    reason?: string;
    related?: ObjectReference;
    reportingComponent?: string;
    reportingInstance?: string;
    series?: EventSeries;
    source?: EventSource;
    type?: string;
}
export interface EventList extends Resource {
    apiVersion?: 'v1';
    items: Array<Event>;
    kind?: 'EventList';
    metadata?: ListMeta;
}
export interface EventSeries {
    count?: number;
    lastObservedTime?: MicroTime;
}
export interface EventSource {
    component?: string;
    host?: string;
}
export interface ExecAction {
    command?: Array<string>;
}
export interface FCVolumeSource {
    fsType?: string;
    lun?: number;
    readOnly?: boolean;
    targetWWNs?: Array<string>;
    wwids?: Array<string>;
}
export interface FlexPersistentVolumeSource {
    driver: string;
    fsType?: string;
    options?: {
        [name: string]: string;
    };
    readOnly?: boolean;
    secretRef?: SecretReference;
}
export interface FlexVolumeSource {
    driver: string;
    fsType?: string;
    options?: {
        [name: string]: string;
    };
    readOnly?: boolean;
    secretRef?: LocalObjectReference;
}
export interface FlockerVolumeSource {
    datasetName?: string;
    datasetUUID?: string;
}
export interface GCEPersistentDiskVolumeSource {
    fsType?: string;
    partition?: number;
    pdName: string;
    readOnly?: boolean;
}
export interface GitRepoVolumeSource {
    directory?: string;
    repository: string;
    revision?: string;
}
export interface GlusterfsPersistentVolumeSource {
    endpoints: string;
    endpointsNamespace?: string;
    path: string;
    readOnly?: boolean;
}
export interface GlusterfsVolumeSource {
    endpoints: string;
    path: string;
    readOnly?: boolean;
}
export interface HTTPGetAction {
    host?: string;
    httpHeaders?: Array<HTTPHeader>;
    path?: string;
    port: number | string;
    scheme?: string;
}
export interface HTTPHeader {
    name: string;
    value: string;
}
export interface Handler {
    exec?: ExecAction;
    httpGet?: HTTPGetAction;
    tcpSocket?: TCPSocketAction;
}
export interface HostAlias {
    hostnames?: Array<string>;
    ip?: string;
}
export interface HostPathVolumeSource {
    path: string;
    type?: string;
}
export interface ISCSIPersistentVolumeSource {
    chapAuthDiscovery?: boolean;
    chapAuthSession?: boolean;
    fsType?: string;
    initiatorName?: string;
    iqn: string;
    iscsiInterface?: string;
    lun: number;
    portals?: Array<string>;
    readOnly?: boolean;
    secretRef?: SecretReference;
    targetPortal: string;
}
export interface ISCSIVolumeSource {
    chapAuthDiscovery?: boolean;
    chapAuthSession?: boolean;
    fsType?: string;
    initiatorName?: string;
    iqn: string;
    iscsiInterface?: string;
    lun: number;
    portals?: Array<string>;
    readOnly?: boolean;
    secretRef?: LocalObjectReference;
    targetPortal: string;
}
export interface KeyToPath {
    key: string;
    mode?: number;
    path: string;
}
export interface Lifecycle {
    postStart?: Handler;
    preStop?: Handler;
}
export interface LimitRange extends Resource {
    apiVersion?: 'v1';
    kind?: 'LimitRange';
    metadata?: ObjectMeta;
    spec?: LimitRangeSpec;
}
export interface LimitRangeItem {
    default?: {
        [name: string]: Quantity;
    };
    defaultRequest?: {
        [name: string]: Quantity;
    };
    max?: {
        [name: string]: Quantity;
    };
    maxLimitRequestRatio?: {
        [name: string]: Quantity;
    };
    min?: {
        [name: string]: Quantity;
    };
    type: string;
}
export interface LimitRangeList extends Resource {
    apiVersion?: 'v1';
    items: Array<LimitRange>;
    kind?: 'LimitRangeList';
    metadata?: ListMeta;
}
export interface LimitRangeSpec {
    limits: Array<LimitRangeItem>;
}
export interface LoadBalancerIngress {
    hostname?: string;
    ip?: string;
    ports?: Array<PortStatus>;
}
export interface LoadBalancerStatus {
    ingress?: Array<LoadBalancerIngress>;
}
export interface LocalObjectReference {
    name?: string;
}
export interface LocalVolumeSource {
    fsType?: string;
    path: string;
}
export interface NFSVolumeSource {
    path: string;
    readOnly?: boolean;
    server: string;
}
export interface Namespace extends Resource {
    apiVersion?: 'v1';
    kind?: 'Namespace';
    metadata?: ObjectMeta;
    spec?: NamespaceSpec;
    status?: NamespaceStatus;
}
export interface NamespaceCondition {
    lastTransitionTime?: Time;
    message?: string;
    reason?: string;
    status: string;
    type: string;
}
export interface NamespaceList extends Resource {
    apiVersion?: 'v1';
    items: Array<Namespace>;
    kind?: 'NamespaceList';
    metadata?: ListMeta;
}
export interface NamespaceSpec {
    finalizers?: Array<string>;
}
export interface NamespaceStatus {
    conditions?: Array<NamespaceCondition>;
    phase?: string;
}
export interface Node extends Resource {
    apiVersion?: 'v1';
    kind?: 'Node';
    metadata?: ObjectMeta;
    spec?: NodeSpec;
    readonly status?: NodeStatus;
}
export interface NodeAddress {
    address: string;
    type: string;
}
export interface NodeAffinity {
    preferredDuringSchedulingIgnoredDuringExecution?: Array<PreferredSchedulingTerm>;
    requiredDuringSchedulingIgnoredDuringExecution?: NodeSelector;
}
export interface NodeCondition {
    lastHeartbeatTime?: Time;
    lastTransitionTime?: Time;
    message?: string;
    reason?: string;
    status: string;
    type: string;
}
export interface NodeConfigSource {
    configMap?: ConfigMapNodeConfigSource;
}
export interface NodeConfigStatus {
    active?: NodeConfigSource;
    assigned?: NodeConfigSource;
    error?: string;
    lastKnownGood?: NodeConfigSource;
}
export interface NodeDaemonEndpoints {
    kubeletEndpoint?: DaemonEndpoint;
}
export interface NodeList extends Resource {
    apiVersion?: 'v1';
    items: Array<Node>;
    kind?: 'NodeList';
    metadata?: ListMeta;
}
export interface NodeSelector {
    nodeSelectorTerms: Array<NodeSelectorTerm>;
}
export interface NodeSelectorRequirement {
    key: string;
    operator: string;
    values?: Array<string>;
}
export interface NodeSelectorTerm {
    matchExpressions?: Array<NodeSelectorRequirement>;
    matchFields?: Array<NodeSelectorRequirement>;
}
export interface NodeSpec {
    configSource?: NodeConfigSource;
    externalID?: string;
    podCIDR?: string;
    podCIDRs?: Array<string>;
    providerID?: string;
    taints?: Array<Taint>;
    unschedulable?: boolean;
}
export interface NodeStatus {
    addresses?: Array<NodeAddress>;
    allocatable?: {
        [name: string]: Quantity;
    };
    capacity?: {
        [name: string]: Quantity;
    };
    conditions?: Array<NodeCondition>;
    config?: NodeConfigStatus;
    daemonEndpoints?: NodeDaemonEndpoints;
    images?: Array<ContainerImage>;
    nodeInfo?: NodeSystemInfo;
    phase?: string;
    volumesAttached?: Array<AttachedVolume>;
    volumesInUse?: Array<string>;
}
export interface NodeSystemInfo {
    architecture: string;
    bootID: string;
    containerRuntimeVersion: string;
    kernelVersion: string;
    kubeProxyVersion: string;
    kubeletVersion: string;
    machineID: string;
    operatingSystem: string;
    osImage: string;
    systemUUID: string;
}
export interface ObjectFieldSelector {
    apiVersion?: string;
    fieldPath: string;
}
export interface ObjectReference {
    apiVersion?: string;
    fieldPath?: string;
    kind?: string;
    name?: string;
    namespace?: string;
    resourceVersion?: string;
    uid?: string;
}
export interface PersistentVolume extends Resource {
    apiVersion?: 'v1';
    kind?: 'PersistentVolume';
    metadata?: ObjectMeta;
    spec?: PersistentVolumeSpec;
    readonly status?: PersistentVolumeStatus;
}
export interface PersistentVolumeClaim extends Resource {
    apiVersion?: 'v1';
    kind?: 'PersistentVolumeClaim';
    metadata?: ObjectMeta;
    spec?: PersistentVolumeClaimSpec;
    readonly status?: PersistentVolumeClaimStatus;
}
export interface PersistentVolumeClaimCondition {
    lastProbeTime?: Time;
    lastTransitionTime?: Time;
    message?: string;
    reason?: string;
    status: string;
    type: string;
}
export interface PersistentVolumeClaimList extends Resource {
    apiVersion?: 'v1';
    items: Array<PersistentVolumeClaim>;
    kind?: 'PersistentVolumeClaimList';
    metadata?: ListMeta;
}
export interface PersistentVolumeClaimSpec {
    accessModes?: Array<string>;
    dataSource?: TypedLocalObjectReference;
    resources?: ResourceRequirements;
    selector?: LabelSelector;
    storageClassName?: string;
    volumeMode?: string;
    volumeName?: string;
}
export interface PersistentVolumeClaimStatus {
    accessModes?: Array<string>;
    capacity?: {
        [name: string]: Quantity;
    };
    conditions?: Array<PersistentVolumeClaimCondition>;
    phase?: string;
}
export interface PersistentVolumeClaimTemplate {
    metadata?: ObjectMeta;
    spec: PersistentVolumeClaimSpec;
}
export interface PersistentVolumeClaimVolumeSource {
    claimName: string;
    readOnly?: boolean;
}
export interface PersistentVolumeList extends Resource {
    apiVersion?: 'v1';
    items: Array<PersistentVolume>;
    kind?: 'PersistentVolumeList';
    metadata?: ListMeta;
}
export interface PersistentVolumeSpec {
    accessModes?: Array<string>;
    awsElasticBlockStore?: AWSElasticBlockStoreVolumeSource;
    azureDisk?: AzureDiskVolumeSource;
    azureFile?: AzureFilePersistentVolumeSource;
    capacity?: {
        [name: string]: Quantity;
    };
    cephfs?: CephFSPersistentVolumeSource;
    cinder?: CinderPersistentVolumeSource;
    claimRef?: ObjectReference;
    csi?: CSIPersistentVolumeSource;
    fc?: FCVolumeSource;
    flexVolume?: FlexPersistentVolumeSource;
    flocker?: FlockerVolumeSource;
    gcePersistentDisk?: GCEPersistentDiskVolumeSource;
    glusterfs?: GlusterfsPersistentVolumeSource;
    hostPath?: HostPathVolumeSource;
    iscsi?: ISCSIPersistentVolumeSource;
    local?: LocalVolumeSource;
    mountOptions?: Array<string>;
    nfs?: NFSVolumeSource;
    nodeAffinity?: VolumeNodeAffinity;
    persistentVolumeReclaimPolicy?: string;
    photonPersistentDisk?: PhotonPersistentDiskVolumeSource;
    portworxVolume?: PortworxVolumeSource;
    quobyte?: QuobyteVolumeSource;
    rbd?: RBDPersistentVolumeSource;
    scaleIO?: ScaleIOPersistentVolumeSource;
    storageClassName?: string;
    storageos?: StorageOSPersistentVolumeSource;
    volumeMode?: string;
    vsphereVolume?: VsphereVirtualDiskVolumeSource;
}
export interface PersistentVolumeStatus {
    message?: string;
    phase?: string;
    reason?: string;
}
export interface PhotonPersistentDiskVolumeSource {
    fsType?: string;
    pdID: string;
}
export interface Pod extends Resource {
    apiVersion?: 'v1';
    kind?: 'Pod';
    metadata?: ObjectMeta;
    spec?: PodSpec;
    readonly status?: PodStatus;
}
export interface PodAffinity {
    preferredDuringSchedulingIgnoredDuringExecution?: Array<WeightedPodAffinityTerm>;
    requiredDuringSchedulingIgnoredDuringExecution?: Array<PodAffinityTerm>;
}
export interface PodAffinityTerm {
    labelSelector?: LabelSelector;
    namespaceSelector?: LabelSelector;
    namespaces?: Array<string>;
    topologyKey: string;
}
export interface PodAntiAffinity {
    preferredDuringSchedulingIgnoredDuringExecution?: Array<WeightedPodAffinityTerm>;
    requiredDuringSchedulingIgnoredDuringExecution?: Array<PodAffinityTerm>;
}
export interface PodCondition {
    lastProbeTime?: Time;
    lastTransitionTime?: Time;
    message?: string;
    reason?: string;
    status: string;
    type: string;
}
export interface PodDNSConfig {
    nameservers?: Array<string>;
    options?: Array<PodDNSConfigOption>;
    searches?: Array<string>;
}
export interface PodDNSConfigOption {
    name?: string;
    value?: string;
}
export interface PodIP {
    ip?: string;
}
export interface PodList extends Resource {
    apiVersion?: 'v1';
    items: Array<Pod>;
    kind?: 'PodList';
    metadata?: ListMeta;
}
export interface PodReadinessGate {
    conditionType: string;
}
export interface PodSecurityContext {
    fsGroup?: number;
    fsGroupChangePolicy?: string;
    runAsGroup?: number;
    runAsNonRoot?: boolean;
    runAsUser?: number;
    seLinuxOptions?: SELinuxOptions;
    seccompProfile?: SeccompProfile;
    supplementalGroups?: Array<number>;
    sysctls?: Array<Sysctl>;
    windowsOptions?: WindowsSecurityContextOptions;
}
export interface PodSpec {
    activeDeadlineSeconds?: number;
    affinity?: Affinity;
    automountServiceAccountToken?: boolean;
    containers: Array<Container>;
    dnsConfig?: PodDNSConfig;
    dnsPolicy?: string;
    enableServiceLinks?: boolean;
    ephemeralContainers?: Array<EphemeralContainer>;
    hostAliases?: Array<HostAlias>;
    hostIPC?: boolean;
    hostNetwork?: boolean;
    hostPID?: boolean;
    hostname?: string;
    imagePullSecrets?: Array<LocalObjectReference>;
    initContainers?: Array<Container>;
    nodeName?: string;
    nodeSelector?: {
        [name: string]: string;
    };
    overhead?: {
        [name: string]: Quantity;
    };
    preemptionPolicy?: string;
    priority?: number;
    priorityClassName?: string;
    readinessGates?: Array<PodReadinessGate>;
    restartPolicy?: string;
    runtimeClassName?: string;
    schedulerName?: string;
    securityContext?: PodSecurityContext;
    serviceAccount?: string;
    serviceAccountName?: string;
    setHostnameAsFQDN?: boolean;
    shareProcessNamespace?: boolean;
    subdomain?: string;
    terminationGracePeriodSeconds?: number;
    tolerations?: Array<Toleration>;
    topologySpreadConstraints?: Array<TopologySpreadConstraint>;
    volumes?: Array<Volume>;
}
export interface PodStatus {
    conditions?: Array<PodCondition>;
    containerStatuses?: Array<ContainerStatus>;
    ephemeralContainerStatuses?: Array<ContainerStatus>;
    hostIP?: string;
    initContainerStatuses?: Array<ContainerStatus>;
    message?: string;
    nominatedNodeName?: string;
    phase?: string;
    podIP?: string;
    podIPs?: Array<PodIP>;
    qosClass?: string;
    reason?: string;
    startTime?: Time;
}
export interface PodTemplate extends Resource {
    apiVersion?: 'v1';
    kind?: 'PodTemplate';
    metadata?: ObjectMeta;
    template?: PodTemplateSpec;
}
export interface PodTemplateList extends Resource {
    apiVersion?: 'v1';
    items: Array<PodTemplate>;
    kind?: 'PodTemplateList';
    metadata?: ListMeta;
}
export interface PodTemplateSpec {
    metadata?: ObjectMeta;
    spec?: PodSpec;
}
export interface PortStatus {
    error?: string;
    port: number;
    protocol: string;
}
export interface PortworxVolumeSource {
    fsType?: string;
    readOnly?: boolean;
    volumeID: string;
}
export interface PreferredSchedulingTerm {
    preference: NodeSelectorTerm;
    weight: number;
}
export interface Probe {
    exec?: ExecAction;
    failureThreshold?: number;
    httpGet?: HTTPGetAction;
    initialDelaySeconds?: number;
    periodSeconds?: number;
    successThreshold?: number;
    tcpSocket?: TCPSocketAction;
    terminationGracePeriodSeconds?: number;
    timeoutSeconds?: number;
}
export interface ProjectedVolumeSource {
    defaultMode?: number;
    sources?: Array<VolumeProjection>;
}
export interface QuobyteVolumeSource {
    group?: string;
    readOnly?: boolean;
    registry: string;
    tenant?: string;
    user?: string;
    volume: string;
}
export interface RBDPersistentVolumeSource {
    fsType?: string;
    image: string;
    keyring?: string;
    monitors: Array<string>;
    pool?: string;
    readOnly?: boolean;
    secretRef?: SecretReference;
    user?: string;
}
export interface RBDVolumeSource {
    fsType?: string;
    image: string;
    keyring?: string;
    monitors: Array<string>;
    pool?: string;
    readOnly?: boolean;
    secretRef?: LocalObjectReference;
    user?: string;
}
export interface ReplicationController extends Resource {
    apiVersion?: 'v1';
    kind?: 'ReplicationController';
    metadata?: ObjectMeta;
    spec?: ReplicationControllerSpec;
    readonly status?: ReplicationControllerStatus;
}
export interface ReplicationControllerCondition {
    lastTransitionTime?: Time;
    message?: string;
    reason?: string;
    status: string;
    type: string;
}
export interface ReplicationControllerList extends Resource {
    apiVersion?: 'v1';
    items: Array<ReplicationController>;
    kind?: 'ReplicationControllerList';
    metadata?: ListMeta;
}
export interface ReplicationControllerSpec {
    minReadySeconds?: number;
    replicas?: number;
    selector?: {
        [name: string]: string;
    };
    template?: PodTemplateSpec;
}
export interface ReplicationControllerStatus {
    availableReplicas?: number;
    conditions?: Array<ReplicationControllerCondition>;
    fullyLabeledReplicas?: number;
    observedGeneration?: number;
    readyReplicas?: number;
    replicas: number;
}
export interface ResourceFieldSelector {
    containerName?: string;
    divisor?: Quantity;
    resource: string;
}
export interface ResourceQuota extends Resource {
    apiVersion?: 'v1';
    kind?: 'ResourceQuota';
    metadata?: ObjectMeta;
    spec?: ResourceQuotaSpec;
    status?: ResourceQuotaStatus;
}
export interface ResourceQuotaList extends Resource {
    apiVersion?: 'v1';
    items: Array<ResourceQuota>;
    kind?: 'ResourceQuotaList';
    metadata?: ListMeta;
}
export interface ResourceQuotaSpec {
    hard?: {
        [name: string]: Quantity;
    };
    scopeSelector?: ScopeSelector;
    scopes?: Array<string>;
}
export interface ResourceQuotaStatus {
    hard?: {
        [name: string]: Quantity;
    };
    used?: {
        [name: string]: Quantity;
    };
}
export interface ResourceRequirements {
    limits?: {
        [name: string]: Quantity;
    };
    requests?: {
        [name: string]: Quantity;
    };
}
export interface SELinuxOptions {
    level?: string;
    role?: string;
    type?: string;
    user?: string;
}
export interface ScaleIOPersistentVolumeSource {
    fsType?: string;
    gateway: string;
    protectionDomain?: string;
    readOnly?: boolean;
    secretRef: SecretReference;
    sslEnabled?: boolean;
    storageMode?: string;
    storagePool?: string;
    system: string;
    volumeName?: string;
}
export interface ScaleIOVolumeSource {
    fsType?: string;
    gateway: string;
    protectionDomain?: string;
    readOnly?: boolean;
    secretRef: LocalObjectReference;
    sslEnabled?: boolean;
    storageMode?: string;
    storagePool?: string;
    system: string;
    volumeName?: string;
}
export interface ScopeSelector {
    matchExpressions?: Array<ScopedResourceSelectorRequirement>;
}
export interface ScopedResourceSelectorRequirement {
    operator: string;
    scopeName: string;
    values?: Array<string>;
}
export interface SeccompProfile {
    localhostProfile?: string;
    type: string;
}
export interface Secret extends Resource {
    apiVersion?: 'v1';
    data?: {
        [name: string]: string;
    };
    immutable?: boolean;
    kind?: 'Secret';
    metadata?: ObjectMeta;
    stringData?: {
        [name: string]: string;
    };
    type?: string;
}
export interface SecretEnvSource {
    name?: string;
    optional?: boolean;
}
export interface SecretKeySelector {
    key: string;
    name?: string;
    optional?: boolean;
}
export interface SecretList extends Resource {
    apiVersion?: 'v1';
    items: Array<Secret>;
    kind?: 'SecretList';
    metadata?: ListMeta;
}
export interface SecretProjection {
    items?: Array<KeyToPath>;
    name?: string;
    optional?: boolean;
}
export interface SecretReference {
    name?: string;
    namespace?: string;
}
export interface SecretVolumeSource {
    defaultMode?: number;
    items?: Array<KeyToPath>;
    optional?: boolean;
    secretName?: string;
}
export interface SecurityContext {
    allowPrivilegeEscalation?: boolean;
    capabilities?: Capabilities;
    privileged?: boolean;
    procMount?: string;
    readOnlyRootFilesystem?: boolean;
    runAsGroup?: number;
    runAsNonRoot?: boolean;
    runAsUser?: number;
    seLinuxOptions?: SELinuxOptions;
    seccompProfile?: SeccompProfile;
    windowsOptions?: WindowsSecurityContextOptions;
}
export interface Service extends Resource {
    apiVersion?: 'v1';
    kind?: 'Service';
    metadata?: ObjectMeta;
    spec?: ServiceSpec;
    readonly status?: ServiceStatus;
}
export interface ServiceAccount extends Resource {
    apiVersion?: 'v1';
    automountServiceAccountToken?: boolean;
    imagePullSecrets?: Array<LocalObjectReference>;
    kind?: 'ServiceAccount';
    metadata?: ObjectMeta;
    secrets?: Array<ObjectReference>;
}
export interface ServiceAccountList extends Resource {
    apiVersion?: 'v1';
    items: Array<ServiceAccount>;
    kind?: 'ServiceAccountList';
    metadata?: ListMeta;
}
export interface ServiceAccountTokenProjection {
    audience?: string;
    expirationSeconds?: number;
    path: string;
}
export interface ServiceList extends Resource {
    apiVersion?: 'v1';
    items: Array<Service>;
    kind?: 'ServiceList';
    metadata?: ListMeta;
}
export interface ServicePort {
    appProtocol?: string;
    name?: string;
    nodePort?: number;
    port: number;
    protocol?: string;
    targetPort?: number | string;
}
export interface ServiceSpec {
    allocateLoadBalancerNodePorts?: boolean;
    clusterIP?: string;
    clusterIPs?: Array<string>;
    externalIPs?: Array<string>;
    externalName?: string;
    externalTrafficPolicy?: string;
    healthCheckNodePort?: number;
    internalTrafficPolicy?: string;
    ipFamilies?: Array<string>;
    ipFamilyPolicy?: string;
    loadBalancerClass?: string;
    loadBalancerIP?: string;
    loadBalancerSourceRanges?: Array<string>;
    ports?: Array<ServicePort>;
    publishNotReadyAddresses?: boolean;
    selector?: {
        [name: string]: string;
    };
    sessionAffinity?: string;
    sessionAffinityConfig?: SessionAffinityConfig;
    topologyKeys?: Array<string>;
    type?: string;
}
export interface ServiceStatus {
    conditions?: Array<Condition>;
    loadBalancer?: LoadBalancerStatus;
}
export interface SessionAffinityConfig {
    clientIP?: ClientIPConfig;
}
export interface StorageOSPersistentVolumeSource {
    fsType?: string;
    readOnly?: boolean;
    secretRef?: ObjectReference;
    volumeName?: string;
    volumeNamespace?: string;
}
export interface StorageOSVolumeSource {
    fsType?: string;
    readOnly?: boolean;
    secretRef?: LocalObjectReference;
    volumeName?: string;
    volumeNamespace?: string;
}
export interface Sysctl {
    name: string;
    value: string;
}
export interface TCPSocketAction {
    host?: string;
    port: number | string;
}
export interface Taint {
    effect: string;
    key: string;
    timeAdded?: Time;
    value?: string;
}
export interface Toleration {
    effect?: string;
    key?: string;
    operator?: string;
    tolerationSeconds?: number;
    value?: string;
}
export interface TopologySelectorLabelRequirement {
    key: string;
    values: Array<string>;
}
export interface TopologySelectorTerm {
    matchLabelExpressions?: Array<TopologySelectorLabelRequirement>;
}
export interface TopologySpreadConstraint {
    labelSelector?: LabelSelector;
    maxSkew: number;
    topologyKey: string;
    whenUnsatisfiable: string;
}
export interface TypedLocalObjectReference {
    apiGroup?: string;
    kind: string;
    name: string;
}
export interface Volume {
    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: string;
    nfs?: NFSVolumeSource;
    persistentVolumeClaim?: PersistentVolumeClaimVolumeSource;
    photonPersistentDisk?: PhotonPersistentDiskVolumeSource;
    portworxVolume?: PortworxVolumeSource;
    projected?: ProjectedVolumeSource;
    quobyte?: QuobyteVolumeSource;
    rbd?: RBDVolumeSource;
    scaleIO?: ScaleIOVolumeSource;
    secret?: SecretVolumeSource;
    storageos?: StorageOSVolumeSource;
    vsphereVolume?: VsphereVirtualDiskVolumeSource;
}
export interface VolumeDevice {
    devicePath: string;
    name: string;
}
export interface VolumeMount {
    mountPath: string;
    mountPropagation?: string;
    name: string;
    readOnly?: boolean;
    subPath?: string;
    subPathExpr?: string;
}
export interface VolumeNodeAffinity {
    required?: NodeSelector;
}
export interface VolumeProjection {
    configMap?: ConfigMapProjection;
    downwardAPI?: DownwardAPIProjection;
    secret?: SecretProjection;
    serviceAccountToken?: ServiceAccountTokenProjection;
}
export interface VsphereVirtualDiskVolumeSource {
    fsType?: string;
    storagePolicyID?: string;
    storagePolicyName?: string;
    volumePath: string;
}
export interface WeightedPodAffinityTerm {
    podAffinityTerm: PodAffinityTerm;
    weight: number;
}
export interface WindowsSecurityContextOptions {
    gmsaCredentialSpec?: string;
    gmsaCredentialSpecName?: string;
    runAsUserName?: string;
}