"type": "string"
          },
          "status": {
            "description": "`status` is the status of the condition. Can be True, False, Unknown. Required.",
            "type": "string"
          },
          "type": {
            "description": "`type` is the type of the condition. Required.",
            "type": "string"
          }

			Type:               v1.PodReady,
			Status:             v1.ConditionTrue,
			LastTransitionTime: metav1.Time{Time: lastTransitionTime},
		}
		pod.Status.Conditions = append(pod.Status.Conditions, *existingCondition)
	}
	podutil.UpdatePodCondition(&pod.Status, &condition)
	fakeResourceVersion(pod)
	om.podsIndexer.Update(pod)
	return om.podsLister.Pods(set.Namespace).List(selector)
}

        "properties": {
          "conditions": {
            "description": "conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met.",
            "items": {
              "allOf": [
                {

  if (else_reg->empty()) else_reg = nullptr;

  bool condition;
  if (auto cond_attr = operands.front().dyn_cast_or_null<IntegerAttr>()) {
    condition = cond_attr.getValue().isOne();

    // Add the successor regions using the condition.
    regions.push_back(RegionSuccessor(condition ? &getThenRegion() : else_reg));
  } else {
    // If the condition isn't constant, both regions may be executed.

			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, JobCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {

		inputs []v1.NodeConditionType
		item   v1.NodeConditionType
		result bool
	}{
		"has-condition": {
			inputs: []v1.NodeConditionType{v1.NodeReady, v1.NodeDiskPressure, v1.NodeMemoryPressure},
			item:   v1.NodeMemoryPressure,
			result: true,
		},
		"does-not-have-condition": {
			inputs: []v1.NodeConditionType{v1.NodeReady, v1.NodeDiskPressure},
			item:   v1.NodeMemoryPressure,

	// Update pod condition to highPod.
	podutil.UpdatePodCondition(&highPod.Status, &v1.PodCondition{
		Type:    v1.PodScheduled,
		Status:  v1.ConditionFalse,
		Reason:  v1.PodReasonUnschedulable,
		Message: "fake scheduling failure",
	})

	// Update pod condition to midPod.
	podutil.UpdatePodCondition(&midPod.Status, &v1.PodCondition{

						tcpRulesInTo = true
					}
				}
			}
			for _, condition := range rule.GetWhen() {
				key := condition.GetKey()
				if key == "" {
					errs = appendErrors(errs, fmt.Errorf("`key` must not be empty"))
				} else {
					if len(condition.GetValues()) == 0 && len(condition.GetNotValues()) == 0 {

					t.Fatalf("Manager should have selected a pod for eviction")
				}

				wantPodStatus := tc.wantPodStatus.DeepCopy()
				if enablePodDisruptionConditions {
					wantPodStatus.Conditions = append(wantPodStatus.Conditions, v1.PodCondition{
						Type:    "DisruptionTarget",
						Status:  "True",
						Reason:  "TerminationByKubelet",

            "description": "The reason for the condition's last transition.",
            "type": "string"
          },
          "status": {
            "default": "",
            "description": "Status of the condition, one of True, False, Unknown.",
            "type": "string"
          },
          "type": {
            "default": "",
            "description": "Type of the condition.",
            "type": "string"