package v1

import (
	"cue.dev/x/k8s.io/apimachinery/pkg/runtime"
	"cue.dev/x/k8s.io/apimachinery/pkg/apis/meta/v1"
	v1_9 "cue.dev/x/k8s.io/api/core/v1"
	"cue.dev/x/k8s.io/apimachinery/pkg/util/intstr"
)

// ControllerRevision implements an immutable snapshot of state
// data. Clients are responsible for serializing and
// deserializing the objects that contain their internal state.
// Once a ControllerRevision has been successfully created, it
// can not be updated. The API Server will fail validation of all
// requests that attempt to mutate the Data field.
// ControllerRevisions may, however, be deleted. Note that, due
// to its use by both the DaemonSet and StatefulSet controllers
// for update and rollback, this object is beta. However, it may
// be subject to name and representation changes in future
// releases, and clients should not depend on its stability. It
// is primarily for internal use by controllers.
#ControllerRevision: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Data is the serialized representation of the state.
	"data"?: runtime.#RawExtension

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ControllerRevision"

	// Standard object's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// Revision indicates the revision of the state represented by
	// Data.
	"revision"!: int64 & int
}

// ControllerRevisionList is a resource containing a list of
// ControllerRevision objects.
#ControllerRevisionList: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Items is the list of ControllerRevisions
	"items"!: [...#ControllerRevision]

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ControllerRevisionList"

	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// DaemonSet represents the configuration of a daemon set.
#DaemonSet: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "DaemonSet"

	// Standard object's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// The desired behavior of this daemon set. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	"spec"?: #DaemonSetSpec

	// The current status of this daemon set. This data may be out of
	// date by some window of time. Populated by the system.
	// Read-only. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	"status"?: #DaemonSetStatus
}

// DaemonSetCondition describes the state of a DaemonSet at a
// certain point.
#DaemonSetCondition: {
	// Last time the condition transitioned from one status to
	// another.
	"lastTransitionTime"?: v1.#Time

	// A human readable message indicating details about the
	// transition.
	"message"?: string

	// The reason for the condition's last transition.
	"reason"?: string

	// Status of the condition, one of True, False, Unknown.
	"status"!: string

	// Type of DaemonSet condition.
	"type"!: string
}

// DaemonSetList is a collection of daemon sets.
#DaemonSetList: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// A list of daemon sets.
	"items"!: [...#DaemonSet]

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "DaemonSetList"

	// Standard list metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// DaemonSetSpec is the specification of a daemon set.
#DaemonSetSpec: {
	// The minimum number of seconds for which a newly created
	// DaemonSet pod should be ready without any of its container
	// crashing, for it to be considered available. Defaults to 0
	// (pod will be considered available as soon as it is ready).
	"minReadySeconds"?: int32 & int

	// The number of old history to retain to allow rollback. This is
	// a pointer to distinguish between explicit zero and not
	// specified. Defaults to 10.
	"revisionHistoryLimit"?: int32 & int

	// A label query over pods that are managed by the daemon set.
	// Must match in order to be controlled. It must match the pod
	// template's labels. More info:
	// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
	"selector"!: v1.#LabelSelector

	// An object that describes the pod that will be created. The
	// DaemonSet will create exactly one copy of this pod on every
	// node that matches the template's node selector (or on every
	// node if no node selector is specified). The only allowed
	// template.spec.restartPolicy value is "Always". More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template
	"template"!: v1_9.#PodTemplateSpec

	// An update strategy to replace existing DaemonSet pods with new
	// pods.
	"updateStrategy"?: #DaemonSetUpdateStrategy
}

// DaemonSetStatus represents the current status of a daemon set.
#DaemonSetStatus: {
	// Count of hash collisions for the DaemonSet. The DaemonSet
	// controller uses this field as a collision avoidance mechanism
	// when it needs to create the name for the newest
	// ControllerRevision.
	"collisionCount"?: int32 & int

	// Represents the latest available observations of a DaemonSet's
	// current state.
	"conditions"?: [...#DaemonSetCondition]

	// The number of nodes that are running at least 1 daemon pod and
	// are supposed to run the daemon pod. More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/
	"currentNumberScheduled"!: int32 & int

	// The total number of nodes that should be running the daemon pod
	// (including nodes correctly running the daemon pod). More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/
	"desiredNumberScheduled"!: int32 & int

	// The number of nodes that should be running the daemon pod and
	// have one or more of the daemon pod running and available
	// (ready for at least spec.minReadySeconds)
	"numberAvailable"?: int32 & int

	// The number of nodes that are running the daemon pod, but are
	// not supposed to run the daemon pod. More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/
	"numberMisscheduled"!: int32 & int

	// numberReady is the number of nodes that should be running the
	// daemon pod and have one or more of the daemon pod running with
	// a Ready Condition.
	"numberReady"!: int32 & int

	// The number of nodes that should be running the daemon pod and
	// have none of the daemon pod running and available (ready for
	// at least spec.minReadySeconds)
	"numberUnavailable"?: int32 & int

	// The most recent generation observed by the daemon set
	// controller.
	"observedGeneration"?: int64 & int

	// The total number of nodes that are running updated daemon pod
	"updatedNumberScheduled"?: int32 & int
}

// DaemonSetUpdateStrategy is a struct used to control the update
// strategy for a DaemonSet.
#DaemonSetUpdateStrategy: {
	// Rolling update config params. Present only if type =
	// "RollingUpdate".
	"rollingUpdate"?: #RollingUpdateDaemonSet

	// Type of daemon set update. Can be "RollingUpdate" or
	// "OnDelete". Default is RollingUpdate.
	"type"?: string
}

// Deployment enables declarative updates for Pods and
// ReplicaSets.
#Deployment: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "Deployment"

	// Standard object's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// Specification of the desired behavior of the Deployment.
	"spec"?: #DeploymentSpec

	// Most recently observed status of the Deployment.
	"status"?: #DeploymentStatus
}

// DeploymentCondition describes the state of a deployment at a
// certain point.
#DeploymentCondition: {
	// Last time the condition transitioned from one status to
	// another.
	"lastTransitionTime"?: v1.#Time

	// The last time this condition was updated.
	"lastUpdateTime"?: v1.#Time

	// A human readable message indicating details about the
	// transition.
	"message"?: string

	// The reason for the condition's last transition.
	"reason"?: string

	// Status of the condition, one of True, False, Unknown.
	"status"!: string

	// Type of deployment condition.
	"type"!: string
}

// DeploymentList is a list of Deployments.
#DeploymentList: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Items is the list of Deployments.
	"items"!: [...#Deployment]

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "DeploymentList"

	// Standard list metadata.
	"metadata"?: v1.#ListMeta
}

// DeploymentSpec is the specification of the desired behavior of
// the Deployment.
#DeploymentSpec: {
	// Minimum number of seconds for which a newly created pod should
	// be ready without any of its container crashing, for it to be
	// considered available. Defaults to 0 (pod will be considered
	// available as soon as it is ready)
	"minReadySeconds"?: int32 & int

	// Indicates that the deployment is paused.
	"paused"?: bool

	// The maximum time in seconds for a deployment to make progress
	// before it is considered to be failed. The deployment
	// controller will continue to process failed deployments and a
	// condition with a ProgressDeadlineExceeded reason will be
	// surfaced in the deployment status. Note that progress will not
	// be estimated during the time a deployment is paused. Defaults
	// to 600s.
	"progressDeadlineSeconds"?: int32 & int

	// Number of desired pods. This is a pointer to distinguish
	// between explicit zero and not specified. Defaults to 1.
	"replicas"?: int32 & int

	// The number of old ReplicaSets to retain to allow rollback. This
	// is a pointer to distinguish between explicit zero and not
	// specified. Defaults to 10.
	"revisionHistoryLimit"?: int32 & int

	// Label selector for pods. Existing ReplicaSets whose pods are
	// selected by this will be the ones affected by this deployment.
	// It must match the pod template's labels.
	"selector"!: v1.#LabelSelector

	// The deployment strategy to use to replace existing pods with
	// new ones.
	"strategy"?: #DeploymentStrategy

	// Template describes the pods that will be created. The only
	// allowed template.spec.restartPolicy value is "Always".
	"template"!: v1_9.#PodTemplateSpec
}

// DeploymentStatus is the most recently observed status of the
// Deployment.
#DeploymentStatus: {
	// Total number of available non-terminating pods (ready for at
	// least minReadySeconds) targeted by this deployment.
	"availableReplicas"?: int32 & int

	// Count of hash collisions for the Deployment. The Deployment
	// controller uses this field as a collision avoidance mechanism
	// when it needs to create the name for the newest ReplicaSet.
	"collisionCount"?: int32 & int

	// Represents the latest available observations of a deployment's
	// current state.
	"conditions"?: [...#DeploymentCondition]

	// The generation observed by the deployment controller.
	"observedGeneration"?: int64 & int

	// Total number of non-terminating pods targeted by this
	// Deployment with a Ready Condition.
	"readyReplicas"?: int32 & int

	// Total number of non-terminating pods targeted by this
	// deployment (their labels match the selector).
	"replicas"?: int32 & int

	// Total number of terminating pods targeted by this deployment.
	// Terminating pods have a non-null .metadata.deletionTimestamp
	// and have not yet reached the Failed or Succeeded
	// .status.phase.
	//
	// This is a beta field and requires enabling
	// DeploymentReplicaSetTerminatingReplicas feature (enabled by
	// default).
	"terminatingReplicas"?: int32 & int

	// Total number of unavailable pods targeted by this deployment.
	// This is the total number of pods that are still required for
	// the deployment to have 100% available capacity. They may
	// either be pods that are running but not yet available or pods
	// that still have not been created.
	"unavailableReplicas"?: int32 & int

	// Total number of non-terminating pods targeted by this
	// deployment that have the desired template spec.
	"updatedReplicas"?: int32 & int
}

// DeploymentStrategy describes how to replace existing pods with
// new ones.
#DeploymentStrategy: {
	// Rolling update config params. Present only if
	// DeploymentStrategyType = RollingUpdate.
	"rollingUpdate"?: #RollingUpdateDeployment

	// Type of deployment. Can be "Recreate" or "RollingUpdate".
	// Default is RollingUpdate.
	"type"?: string
}

// ReplicaSet ensures that a specified number of pod replicas are
// running at any given time.
#ReplicaSet: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ReplicaSet"

	// If the Labels of a ReplicaSet are empty, they are defaulted to
	// be the same as the Pod(s) that the ReplicaSet manages.
	// Standard object's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// Spec defines the specification of the desired behavior of the
	// ReplicaSet. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	"spec"?: #ReplicaSetSpec

	// Status is the most recently observed status of the ReplicaSet.
	// This data may be out of date by some window of time. Populated
	// by the system. Read-only. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	"status"?: #ReplicaSetStatus
}

// ReplicaSetCondition describes the state of a replica set at a
// certain point.
#ReplicaSetCondition: {
	// The last time the condition transitioned from one status to
	// another.
	"lastTransitionTime"?: v1.#Time

	// A human readable message indicating details about the
	// transition.
	"message"?: string

	// The reason for the condition's last transition.
	"reason"?: string

	// Status of the condition, one of True, False, Unknown.
	"status"!: string

	// Type of replica set condition.
	"type"!: string
}

// ReplicaSetList is a collection of ReplicaSets.
#ReplicaSetList: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// List of ReplicaSets. More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/replicaset
	"items"!: [...#ReplicaSet]

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ReplicaSetList"

	// Standard list metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"metadata"?: v1.#ListMeta
}

// ReplicaSetSpec is the specification of a ReplicaSet.
#ReplicaSetSpec: {
	// Minimum number of seconds for which a newly created pod should
	// be ready without any of its container crashing, for it to be
	// considered available. Defaults to 0 (pod will be considered
	// available as soon as it is ready)
	"minReadySeconds"?: int32 & int

	// Replicas is the number of desired pods. This is a pointer to
	// distinguish between explicit zero and unspecified. Defaults to
	// 1. More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/replicaset
	"replicas"?: int32 & int

	// Selector is a label query over pods that should match the
	// replica count. Label keys and values that must match in order
	// to be controlled by this replica set. It must match the pod
	// template's labels. More info:
	// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
	"selector"!: v1.#LabelSelector

	// Template is the object that describes the pod that will be
	// created if insufficient replicas are detected. More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/#pod-template
	"template"?: v1_9.#PodTemplateSpec
}

// ReplicaSetStatus represents the current status of a ReplicaSet.
#ReplicaSetStatus: {
	// The number of available non-terminating pods (ready for at
	// least minReadySeconds) for this replica set.
	"availableReplicas"?: int32 & int

	// Represents the latest available observations of a replica set's
	// current state.
	"conditions"?: [...#ReplicaSetCondition]

	// The number of non-terminating pods that have labels matching
	// the labels of the pod template of the replicaset.
	"fullyLabeledReplicas"?: int32 & int

	// ObservedGeneration reflects the generation of the most recently
	// observed ReplicaSet.
	"observedGeneration"?: int64 & int

	// The number of non-terminating pods targeted by this ReplicaSet
	// with a Ready Condition.
	"readyReplicas"?: int32 & int

	// Replicas is the most recently observed number of
	// non-terminating pods. More info:
	// https://kubernetes.io/docs/concepts/workloads/controllers/replicaset
	"replicas"!: int32 & int

	// The number of terminating pods for this replica set.
	// Terminating pods have a non-null .metadata.deletionTimestamp
	// and have not yet reached the Failed or Succeeded
	// .status.phase.
	//
	// This is a beta field and requires enabling
	// DeploymentReplicaSetTerminatingReplicas feature (enabled by
	// default).
	"terminatingReplicas"?: int32 & int
}

// Spec to control the desired behavior of daemon set rolling
// update.
#RollingUpdateDaemonSet: {
	// The maximum number of nodes with an existing available
	// DaemonSet pod that can have an updated DaemonSet pod during
	// during an update. Value can be an absolute number (ex: 5) or a
	// percentage of desired pods (ex: 10%). This can not be 0 if
	// MaxUnavailable is 0. Absolute number is calculated from
	// percentage by rounding up to a minimum of 1. Default value is
	// 0. Example: when this is set to 30%, at most 30% of the total
	// number of nodes that should be running the daemon pod (i.e.
	// status.desiredNumberScheduled) can have their a new pod
	// created before the old pod is marked as deleted. The update
	// starts by launching new pods on 30% of nodes. Once an updated
	// pod is available (Ready for at least minReadySeconds) the old
	// DaemonSet pod on that node is marked deleted. If the old pod
	// becomes unavailable for any reason (Ready transitions to
	// false, is evicted, or is drained) an updated pod is
	// immediately created on that node without considering surge
	// limits. Allowing surge implies the possibility that the
	// resources consumed by the daemonset on any given node can
	// double if the readiness check fails, and so resource intensive
	// daemonsets should take into account that they may cause
	// evictions during disruption.
	"maxSurge"?: intstr.#IntOrString

	// The maximum number of DaemonSet pods that can be unavailable
	// during the update. Value can be an absolute number (ex: 5) or
	// a percentage of total number of DaemonSet pods at the start of
	// the update (ex: 10%). Absolute number is calculated from
	// percentage by rounding up. This cannot be 0 if MaxSurge is 0
	// Default value is 1. Example: when this is set to 30%, at most
	// 30% of the total number of nodes that should be running the
	// daemon pod (i.e. status.desiredNumberScheduled) can have their
	// pods stopped for an update at any given time. The update
	// starts by stopping at most 30% of those DaemonSet pods and
	// then brings up new DaemonSet pods in their place. Once the new
	// pods are available, it then proceeds onto other DaemonSet
	// pods, thus ensuring that at least 70% of original number of
	// DaemonSet pods are available at all times during the update.
	"maxUnavailable"?: intstr.#IntOrString
}

// Spec to control the desired behavior of rolling update.
#RollingUpdateDeployment: {
	// The maximum number of pods that can be scheduled above the
	// desired number of pods. Value can be an absolute number (ex:
	// 5) or a percentage of desired pods (ex: 10%). This can not be
	// 0 if MaxUnavailable is 0. Absolute number is calculated from
	// percentage by rounding up. Defaults to 25%. Example: when this
	// is set to 30%, the new ReplicaSet can be scaled up immediately
	// when the rolling update starts, such that the total number of
	// old and new pods do not exceed 130% of desired pods. Once old
	// pods have been killed, new ReplicaSet can be scaled up
	// further, ensuring that total number of pods running at any
	// time during the update is at most 130% of desired pods.
	"maxSurge"?: intstr.#IntOrString

	// The maximum number of pods that can be unavailable during the
	// update. Value can be an absolute number (ex: 5) or a
	// percentage of desired pods (ex: 10%). Absolute number is
	// calculated from percentage by rounding down. This can not be 0
	// if MaxSurge is 0. Defaults to 25%. Example: when this is set
	// to 30%, the old ReplicaSet can be scaled down to 70% of
	// desired pods immediately when the rolling update starts. Once
	// new pods are ready, old ReplicaSet can be scaled down further,
	// followed by scaling up the new ReplicaSet, ensuring that the
	// total number of pods available at all times during the update
	// is at least 70% of desired pods.
	"maxUnavailable"?: intstr.#IntOrString
}

// RollingUpdateStatefulSetStrategy is used to communicate
// parameter for RollingUpdateStatefulSetStrategyType.
#RollingUpdateStatefulSetStrategy: {
	// The maximum number of pods that can be unavailable during the
	// update. Value can be an absolute number (ex: 5) or a
	// percentage of desired pods (ex: 10%). Absolute number is
	// calculated from percentage by rounding up. This can not be 0.
	// Defaults to 1. This field is beta-level and is enabled by
	// default. The field applies to all pods in the range 0 to
	// Replicas-1. That means if there is any unavailable pod in the
	// range 0 to Replicas-1, it will be counted towards
	// MaxUnavailable. This setting might not be effective for the
	// OrderedReady podManagementPolicy. That policy ensures pods are
	// created and become ready one at a time.
	"maxUnavailable"?: intstr.#IntOrString

	// Partition indicates the ordinal at which the StatefulSet should
	// be partitioned for updates. During a rolling update, all pods
	// from ordinal Replicas-1 to Partition are updated. All pods
	// from ordinal Partition-1 to 0 remain untouched. This is
	// helpful in being able to do a canary based deployment. The
	// default value is 0.
	"partition"?: int32 & int
}

// StatefulSet represents a set of pods with consistent
// identities. Identities are defined as:
// - Network: A single stable DNS and hostname.
// - Storage: As many VolumeClaims as requested.
//
// The StatefulSet guarantees that a given network identity will
// always map to the same storage identity.
#StatefulSet: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "StatefulSet"

	// Standard object's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// Spec defines the desired identities of pods in this set.
	"spec"?: #StatefulSetSpec

	// Status is the current status of Pods in this StatefulSet. This
	// data may be out of date by some window of time.
	"status"?: #StatefulSetStatus
}

// StatefulSetCondition describes the state of a statefulset at a
// certain point.
#StatefulSetCondition: {
	// Last time the condition transitioned from one status to
	// another.
	"lastTransitionTime"?: v1.#Time

	// A human readable message indicating details about the
	// transition.
	"message"?: string

	// The reason for the condition's last transition.
	"reason"?: string

	// Status of the condition, one of True, False, Unknown.
	"status"!: string

	// Type of statefulset condition.
	"type"!: string
}

// StatefulSetList is a collection of StatefulSets.
#StatefulSetList: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "apps/v1"

	// Items is the list of stateful sets.
	"items"!: [...#StatefulSet]

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "StatefulSetList"

	// Standard list's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// StatefulSetOrdinals describes the policy used for replica
// ordinal assignment in this StatefulSet.
#StatefulSetOrdinals: {
	// start is the number representing the first replica's index. It
	// may be used to number replicas from an alternate index (eg:
	// 1-indexed) over the default 0-indexed names, or to orchestrate
	// progressive movement of replicas from one StatefulSet to
	// another. If set, replica indices will be in the range:
	// [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas).
	// If unset, defaults to 0. Replica indices will be in the range:
	// [0, .spec.replicas).
	"start"?: int32 & int
}

// StatefulSetPersistentVolumeClaimRetentionPolicy describes the
// policy used for PVCs created from the StatefulSet
// VolumeClaimTemplates.
#StatefulSetPersistentVolumeClaimRetentionPolicy: {
	// WhenDeleted specifies what happens to PVCs created from
	// StatefulSet VolumeClaimTemplates when the StatefulSet is
	// deleted. The default policy of `Retain` causes PVCs to not be
	// affected by StatefulSet deletion. The `Delete` policy causes
	// those PVCs to be deleted.
	"whenDeleted"?: string

	// WhenScaled specifies what happens to PVCs created from
	// StatefulSet VolumeClaimTemplates when the StatefulSet is
	// scaled down. The default policy of `Retain` causes PVCs to not
	// be affected by a scaledown. The `Delete` policy causes the
	// associated PVCs for any excess pods above the replica count to
	// be deleted.
	"whenScaled"?: string
}

// A StatefulSetSpec is the specification of a StatefulSet.
#StatefulSetSpec: {
	// Minimum number of seconds for which a newly created pod should
	// be ready without any of its container crashing for it to be
	// considered available. Defaults to 0 (pod will be considered
	// available as soon as it is ready)
	"minReadySeconds"?: int32 & int

	// ordinals controls the numbering of replica indices in a
	// StatefulSet. The default ordinals behavior assigns a "0" index
	// to the first replica and increments the index by one for each
	// additional replica requested.
	"ordinals"?: #StatefulSetOrdinals

	// persistentVolumeClaimRetentionPolicy describes the lifecycle of
	// persistent volume claims created from volumeClaimTemplates. By
	// default, all persistent volume claims are created as needed
	// and retained until manually deleted. This policy allows the
	// lifecycle to be altered, for example by deleting persistent
	// volume claims when their stateful set is deleted, or when
	// their pod is scaled down.
	"persistentVolumeClaimRetentionPolicy"?: #StatefulSetPersistentVolumeClaimRetentionPolicy

	// podManagementPolicy controls how pods are created during
	// initial scale up, when replacing pods on nodes, or when
	// scaling down. The default policy is `OrderedReady`, where pods
	// are created in increasing order (pod-0, then pod-1, etc) and
	// the controller will wait until each pod is ready before
	// continuing. When scaling down, the pods are removed in the
	// opposite order. The alternative policy is `Parallel` which
	// will create pods in parallel to match the desired scale
	// without waiting, and on scale down will delete all pods at
	// once.
	"podManagementPolicy"?: string

	// replicas is the desired number of replicas of the given
	// Template. These are replicas in the sense that they are
	// instantiations of the same Template, but individual replicas
	// also have a consistent identity. If unspecified, defaults to
	// 1.
	"replicas"?: int32 & int

	// revisionHistoryLimit is the maximum number of revisions that
	// will be maintained in the StatefulSet's revision history. The
	// revision history consists of all revisions not represented by
	// a currently applied StatefulSetSpec version. The default value
	// is 10.
	"revisionHistoryLimit"?: int32 & int

	// selector is a label query over pods that should match the
	// replica count. It must match the pod template's labels. More
	// info:
	// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
	"selector"!: v1.#LabelSelector

	// serviceName is the name of the service that governs this
	// StatefulSet. This service must exist before the StatefulSet,
	// and is responsible for the network identity of the set. Pods
	// get DNS/hostnames that follow the pattern:
	// pod-specific-string.serviceName.default.svc.cluster.local
	// where "pod-specific-string" is managed by the StatefulSet
	// controller.
	"serviceName"?: string

	// template is the object that describes the pod that will be
	// created if insufficient replicas are detected. Each pod
	// stamped out by the StatefulSet will fulfill this Template, but
	// have a unique identity from the rest of the StatefulSet. Each
	// pod will be named with the format
	// <statefulsetname>-<podindex>. For example, a pod in a
	// StatefulSet named "web" with index number "3" would be named
	// "web-3". The only allowed template.spec.restartPolicy value is
	// "Always".
	"template"!: v1_9.#PodTemplateSpec

	// updateStrategy indicates the StatefulSetUpdateStrategy that
	// will be employed to update Pods in the StatefulSet when a
	// revision is made to Template.
	"updateStrategy"?: #StatefulSetUpdateStrategy

	// volumeClaimTemplates is a list of claims that pods are allowed
	// to reference. The StatefulSet controller is responsible for
	// mapping network identities to claims in a way that maintains
	// the identity of a pod. Every claim in this list must have at
	// least one matching (by name) volumeMount in one container in
	// the template. A claim in this list takes precedence over any
	// volumes in the template, with the same name.
	"volumeClaimTemplates"?: [...v1_9.#PersistentVolumeClaim]
}

// StatefulSetStatus represents the current state of a
// StatefulSet.
#StatefulSetStatus: {
	// Total number of available pods (ready for at least
	// minReadySeconds) targeted by this statefulset.
	"availableReplicas"?: int32 & int

	// collisionCount is the count of hash collisions for the
	// StatefulSet. The StatefulSet controller uses this field as a
	// collision avoidance mechanism when it needs to create the name
	// for the newest ControllerRevision.
	"collisionCount"?: int32 & int

	// Represents the latest available observations of a statefulset's
	// current state.
	"conditions"?: [...#StatefulSetCondition]

	// currentReplicas is the number of Pods created by the
	// StatefulSet controller from the StatefulSet version indicated
	// by currentRevision.
	"currentReplicas"?: int32 & int

	// currentRevision, if not empty, indicates the version of the
	// StatefulSet used to generate Pods in the sequence
	// [0,currentReplicas).
	"currentRevision"?: string

	// observedGeneration is the most recent generation observed for
	// this StatefulSet. It corresponds to the StatefulSet's
	// generation, which is updated on mutation by the API Server.
	"observedGeneration"?: int64 & int

	// readyReplicas is the number of pods created for this
	// StatefulSet with a Ready Condition.
	"readyReplicas"?: int32 & int

	// replicas is the number of Pods created by the StatefulSet
	// controller.
	"replicas"!: int32 & int

	// updateRevision, if not empty, indicates the version of the
	// StatefulSet used to generate Pods in the sequence
	// [replicas-updatedReplicas,replicas)
	"updateRevision"?: string

	// updatedReplicas is the number of Pods created by the
	// StatefulSet controller from the StatefulSet version indicated
	// by updateRevision.
	"updatedReplicas"?: int32 & int
}

// StatefulSetUpdateStrategy indicates the strategy that the
// StatefulSet controller will use to perform updates. It
// includes any additional parameters necessary to perform the
// update for the indicated strategy.
#StatefulSetUpdateStrategy: {
	// RollingUpdate is used to communicate parameters when Type is
	// RollingUpdateStatefulSetStrategyType.
	"rollingUpdate"?: #RollingUpdateStatefulSetStrategy

	// Type indicates the type of the StatefulSetUpdateStrategy.
	// Default is RollingUpdate.
	"type"?: string
}