{
  "description": "NodeFeatureRule resource specifies a configuration for feature-based\ncustomization of node objects, such as node labeling.",
  "properties": {
    "apiVersion": {
      "description": "APIVersion defines the versioned schema of this representation of an object.\nServers should convert recognized schemas to the latest internal value, and\nmay reject unrecognized values.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources",
      "type": "string"
    },
    "kind": {
      "description": "Kind is a string value representing the REST resource this object represents.\nServers may infer this from the endpoint the client submits requests to.\nCannot be updated.\nIn CamelCase.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
      "type": "string"
    },
    "metadata": {
      "type": "object"
    },
    "spec": {
      "description": "Spec defines the rules to be evaluated.",
      "properties": {
        "rules": {
          "description": "Rules is a list of node customization rules.",
          "items": {
            "description": "Rule defines a rule for node customization such as labeling.",
            "properties": {
              "annotations": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "Annotations to create if the rule matches.",
                "type": "object"
              },
              "extendedResources": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "ExtendedResources to create if the rule matches.",
                "type": "object"
              },
              "labels": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "Labels to create if the rule matches.",
                "type": "object"
              },
              "labelsTemplate": {
                "description": "LabelsTemplate specifies a template to expand for dynamically generating\nmultiple labels. Data (after template expansion) must be keys with an\noptional value (<key>[=<value>]) separated by newlines.",
                "type": "string"
              },
              "matchAny": {
                "description": "MatchAny specifies a list of matchers one of which must match.",
                "items": {
                  "description": "MatchAnyElem specifies one sub-matcher of MatchAny.",
                  "properties": {
                    "matchFeatures": {
                      "description": "MatchFeatures specifies a set of matcher terms all of which must match.",
                      "items": {
                        "description": "FeatureMatcherTerm defines requirements against one feature set. All\nrequirements (specified as MatchExpressions) are evaluated against each\nelement in the feature set.",
                        "properties": {
                          "feature": {
                            "description": "Feature is the name of the feature set to match against.",
                            "type": "string"
                          },
                          "matchExpressions": {
                            "additionalProperties": {
                              "description": "MatchExpression specifies an expression to evaluate against a set of input\nvalues. It contains an operator that is applied when matching the input and\nan array of values that the operator evaluates the input against.",
                              "properties": {
                                "op": {
                                  "description": "Op is the operator to be applied.",
                                  "enum": [
                                    "In",
                                    "NotIn",
                                    "InRegexp",
                                    "Exists",
                                    "DoesNotExist",
                                    "Gt",
                                    "Ge",
                                    "Lt",
                                    "Le",
                                    "GtLt",
                                    "GeLe",
                                    "IsTrue",
                                    "IsFalse"
                                  ],
                                  "type": "string"
                                },
                                "type": {
                                  "description": "Type defines the value type for specific operators.\nThe currently supported type is 'version' for Gt,Ge,Lt,Le,GtLt,GeLe operators.",
                                  "type": "string"
                                },
                                "value": {
                                  "description": "Value is the list of values that the operand evaluates the input\nagainst. Value should be empty if the operator is Exists, DoesNotExist,\nIsTrue or IsFalse. Value should contain exactly one element if the\noperator is Gt or Lt and exactly two elements if the operator is GtLt.\nIn other cases Value should contain at least one element.",
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "op"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "description": "MatchExpressions is the set of per-element expressions evaluated. These\nmatch against the value of the specified elements.",
                            "type": "object"
                          },
                          "matchName": {
                            "description": "MatchName in an expression that is matched against the name of each\nelement in the feature set.",
                            "properties": {
                              "op": {
                                "description": "Op is the operator to be applied.",
                                "enum": [
                                  "In",
                                  "NotIn",
                                  "InRegexp",
                                  "Exists",
                                  "DoesNotExist",
                                  "Gt",
                                  "Ge",
                                  "Lt",
                                  "Le",
                                  "GtLt",
                                  "GeLe",
                                  "IsTrue",
                                  "IsFalse"
                                ],
                                "type": "string"
                              },
                              "type": {
                                "description": "Type defines the value type for specific operators.\nThe currently supported type is 'version' for Gt,Ge,Lt,Le,GtLt,GeLe operators.",
                                "type": "string"
                              },
                              "value": {
                                "description": "Value is the list of values that the operand evaluates the input\nagainst. Value should be empty if the operator is Exists, DoesNotExist,\nIsTrue or IsFalse. Value should contain exactly one element if the\noperator is Gt or Lt and exactly two elements if the operator is GtLt.\nIn other cases Value should contain at least one element.",
                                "items": {
                                  "type": "string"
                                },
                                "type": "array"
                              }
                            },
                            "required": [
                              "op"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          }
                        },
                        "required": [
                          "feature"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "matchFeatures"
                  ],
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              },
              "matchFeatures": {
                "description": "MatchFeatures specifies a set of matcher terms all of which must match.",
                "items": {
                  "description": "FeatureMatcherTerm defines requirements against one feature set. All\nrequirements (specified as MatchExpressions) are evaluated against each\nelement in the feature set.",
                  "properties": {
                    "feature": {
                      "description": "Feature is the name of the feature set to match against.",
                      "type": "string"
                    },
                    "matchExpressions": {
                      "additionalProperties": {
                        "description": "MatchExpression specifies an expression to evaluate against a set of input\nvalues. It contains an operator that is applied when matching the input and\nan array of values that the operator evaluates the input against.",
                        "properties": {
                          "op": {
                            "description": "Op is the operator to be applied.",
                            "enum": [
                              "In",
                              "NotIn",
                              "InRegexp",
                              "Exists",
                              "DoesNotExist",
                              "Gt",
                              "Ge",
                              "Lt",
                              "Le",
                              "GtLt",
                              "GeLe",
                              "IsTrue",
                              "IsFalse"
                            ],
                            "type": "string"
                          },
                          "type": {
                            "description": "Type defines the value type for specific operators.\nThe currently supported type is 'version' for Gt,Ge,Lt,Le,GtLt,GeLe operators.",
                            "type": "string"
                          },
                          "value": {
                            "description": "Value is the list of values that the operand evaluates the input\nagainst. Value should be empty if the operator is Exists, DoesNotExist,\nIsTrue or IsFalse. Value should contain exactly one element if the\noperator is Gt or Lt and exactly two elements if the operator is GtLt.\nIn other cases Value should contain at least one element.",
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          }
                        },
                        "required": [
                          "op"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "description": "MatchExpressions is the set of per-element expressions evaluated. These\nmatch against the value of the specified elements.",
                      "type": "object"
                    },
                    "matchName": {
                      "description": "MatchName in an expression that is matched against the name of each\nelement in the feature set.",
                      "properties": {
                        "op": {
                          "description": "Op is the operator to be applied.",
                          "enum": [
                            "In",
                            "NotIn",
                            "InRegexp",
                            "Exists",
                            "DoesNotExist",
                            "Gt",
                            "Ge",
                            "Lt",
                            "Le",
                            "GtLt",
                            "GeLe",
                            "IsTrue",
                            "IsFalse"
                          ],
                          "type": "string"
                        },
                        "type": {
                          "description": "Type defines the value type for specific operators.\nThe currently supported type is 'version' for Gt,Ge,Lt,Le,GtLt,GeLe operators.",
                          "type": "string"
                        },
                        "value": {
                          "description": "Value is the list of values that the operand evaluates the input\nagainst. Value should be empty if the operator is Exists, DoesNotExist,\nIsTrue or IsFalse. Value should contain exactly one element if the\noperator is Gt or Lt and exactly two elements if the operator is GtLt.\nIn other cases Value should contain at least one element.",
                          "items": {
                            "type": "string"
                          },
                          "type": "array"
                        }
                      },
                      "required": [
                        "op"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    }
                  },
                  "required": [
                    "feature"
                  ],
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              },
              "name": {
                "description": "Name of the rule.",
                "type": "string"
              },
              "taints": {
                "description": "Taints to create if the rule matches.",
                "items": {
                  "description": "The node this Taint is attached to has the \"effect\" on\nany pod that does not tolerate the Taint.",
                  "properties": {
                    "effect": {
                      "description": "Required. The effect of the taint on pods\nthat do not tolerate the taint.\nValid effects are NoSchedule, PreferNoSchedule and NoExecute.",
                      "type": "string"
                    },
                    "key": {
                      "description": "Required. The taint key to be applied to a node.",
                      "type": "string"
                    },
                    "timeAdded": {
                      "description": "TimeAdded represents the time at which the taint was added.\nIt is only written for NoExecute taints.",
                      "format": "date-time",
                      "type": "string"
                    },
                    "value": {
                      "description": "The taint value corresponding to the taint key.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "effect",
                    "key"
                  ],
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              },
              "vars": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "Vars is the variables to store if the rule matches. Variables do not\ndirectly inflict any changes in the node object. However, they can be\nreferenced from other rules enabling more complex rule hierarchies,\nwithout exposing intermediary output values as labels.",
                "type": "object"
              },
              "varsTemplate": {
                "description": "VarsTemplate specifies a template to expand for dynamically generating\nmultiple variables. Data (after template expansion) must be keys with an\noptional value (<key>[=<value>]) separated by newlines.",
                "type": "string"
              }
            },
            "required": [
              "name"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        }
      },
      "required": [
        "rules"
      ],
      "type": "object",
      "additionalProperties": false
    }
  },
  "required": [
    "spec"
  ],
  "type": "object"
}