values.schema.json

{
  "$schema": "https://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": [
    "namespace"
  ],
  "properties": {
    "name": {
      "type": "string"
    },
    "namespace": {
      "type": "string"
    },
    "image_pull_policy": {
      "description": "The image pull policy",
      "enum": [
        "Always",
        "always",
        "Never",
        "never",
        "IfNotPresent",
        "ifnotpresent"
      ],
      "type": "string"
    },
    "image_pull_secrets": {
      "description": "Image pull secrets for app and database containers",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "no_log": {
      "default": true,
      "description": "Configure no_log for no_log tasks",
      "type": "boolean"
    },
    "idle_aap": {
      "description": "Scale down replicas to put AAP into an idle mode",
      "type": "boolean"
    },
    "redis_mode": {
      "description": "Redis Mode",
      "enum": [
        "",
        "cluster",
        "standalone"
      ],
      "type": "string"
    },
    "image": {
      "description": "AAP Gateway container image",
      "type": "string"
    },
    "image_version": {
      "description": "AAP Gateway container image version (tag)",
      "type": "string"
    },
    "postgres_image": {
      "description": "Registry path to the PostgreSQL container to use",
      "type": "string"
    },
    "postgres_image_version": {
      "description": "PostgreSQL container image version to use",
      "type": "string"
    },
    "redis_image": {
      "description": "Registry path to the redis container to use",
      "type": "string"
    },
    "redis_image_version": {
      "description": "Redis container image version to use",
      "type": "string"
    },
    "redhat_registry": {
      "description": "Default Redhat Container Image Registry",
      "type": "string"
    },
    "redhat_registry_ns": {
      "description": "Default Redhat Container Image Registry Namespace",
      "type": "string"
    },
    "admin_password_secret": {
      "description": "Secret where the admin password can be found",
      "maxLength": 255,
      "type": "string"
    },
    "bundle_cacert_secret": {
      "description": "Secret where the trusted Certificate Authority Bundle is stored",
      "type": "string"
    },
    "db_fields_encryption_secret": {
      "description": "Secret where the DB fields encryption key can be found. If not specified, one will be generated.",
      "type": "string"
    },
    "hostname": {
      "description": "Override default hostname of the Ansible Automation Platform",
      "type": "string"
    },
    "public_base_url": {
      "description": "Public base URL for AAP",
      "type": "string"
    },
    "route_tls_termination_mechanism": {
      "description": "The secure TLS termination mechanism to use",
      "enum": [
        "",
        "Edge",
        "edge",
        "Passthrough",
        "passthrough"
      ],
      "type": "string"
    },
    "route_tls_secret": {
      "description": "Secret where the TLS related credentials are stored",
      "type": "string"
    },
    "route_host": {
      "description": "The DNS to use to points to the instance",
      "type": "string"
    },
    "route_annotations": {
      "type": "object"
    },
    "ingress_type": {
      "description": "The ingress type to use to reach the deployed instance",
      "enum": [
        "",
        "none",
        "Ingress",
        "ingress",
        "Route",
        "route"
      ],
      "type": "string"
    },
    "ingress_class_name": {
      "description": "The name of ingress class to use instead of the cluster default.",
      "type": "string"
    },
    "ingress_path": {
      "description": "The ingress path used to reach the deployed service",
      "type": "string"
    },
    "ingress_path_type": {
      "description": "The ingress path type for the deployed service",
      "type": "string"
    },
    "ingress_tls_secret": {
      "description": "Secret where the Ingress TLS secret can be found",
      "type": "string"
    },
    "ingress_annotations": {
      "type": "object"
    },
    "service_type": {
      "description": "The service type to be used on the deployed instance",
      "enum": [
        "",
        "LoadBalancer",
        "loadbalancer",
        "ClusterIP",
        "clusterip",
        "NodePort",
        "nodeport"
      ],
      "type": "string"
    },
    "service_annotations": {
      "type": "object"
    },
    "service_account_annotations": {
      "type": "object"
    },
    "loadbalancer_port": {
      "description": "Port to use for the loadbalancer",
      "type": "integer"
    },
    "loadbalancer_protocol": {
      "description": "Protocol to use for the loadbalancer",
      "enum": [
        "http",
        "https"
      ],
      "type": "string"
    },
    "ltm_route_enabled": {
      "type": "boolean"
    },
    "ltm_route_hostname": {
      "type": "string"
    },
    "ltm_route_annotations": {
      "type": "object"
    },
    "ltm_route_labels": {
      "type": "object"
    },
    "extra_settings": {
      "description": "Environment variables to configure the application-level settings",
      "items": {
        "properties": {
          "setting": {
            "type": "string"
          },
          "value": {
            "x-kubernetes-preserve-unknown-fields": true
          }
        },
        "type": "object"
      },
      "type": "array"
    },
    "feature_flags": {
      "type": "object",
      "additionalProperties": false,
      "patternProperties": {
        "^FEATURE_": {
          "type": "boolean"
        }
      }
    },
    "extraSpec": {
      "type": "object"
    },
    "api": {
      "type": "object",
      "properties": {
        "replicas": {
          "default": 1,
          "description": "The number of replicas for the deployment.",
          "format": "int32",
          "type": "integer"
        },
        "log_level": {
          "default": "INFO",
          "description": "The log level for the deployment.",
          "enum": [
            "DEBUG",
            "INFO",
            "WARNING",
            "ERROR",
            "CRITICAL"
          ],
          "type": "string"
        },
        "resource_requirements": {
          "$ref": "#/definitions/resourceRequirements"
        },
        "node_selector": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "NodeSelector for the gateway pods.",
          "type": "object"
        },
        "tolerations": {
          "description": "Node tolerations for the gateway pods.",
          "items": {
            "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
            "properties": {
              "effect": {
                "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                "type": "string"
              },
              "key": {
                "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                "type": "string"
              },
              "operator": {
                "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                "type": "string"
              },
              "tolerationSeconds": {
                "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                "format": "int64",
                "type": "integer"
              },
              "value": {
                "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "topology_spread_constraints": {
          "description": "Topology rule(s) for the pods.",
          "items": {
            "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
            "properties": {
              "labelSelector": {
                "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                "properties": {
                  "matchExpressions": {
                    "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                    "items": {
                      "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                      "properties": {
                        "key": {
                          "description": "key is the label key that the selector applies to.",
                          "type": "string"
                        },
                        "operator": {
                          "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                          "type": "string"
                        },
                        "values": {
                          "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                          "items": {
                            "type": "string"
                          },
                          "type": "array"
                        }
                      },
                      "required": [
                        "key",
                        "operator"
                      ],
                      "type": "object"
                    },
                    "type": "array"
                  },
                  "matchLabels": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                    "type": "object"
                  }
                },
                "type": "object",
                "x-kubernetes-map-type": "atomic"
              },
              "matchLabelKeys": {
                "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                "items": {
                  "type": "string"
                },
                "type": "array",
                "x-kubernetes-list-type": "atomic"
              },
              "maxSkew": {
                "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. Its a required field. Default value is 1 and 0 is not allowed.",
                "format": "int32",
                "type": "integer"
              },
              "minDomains": {
                "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                "format": "int32",
                "type": "integer"
              },
              "nodeAffinityPolicy": {
                "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                "type": "string"
              },
              "nodeTaintsPolicy": {
                "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                "type": "string"
              },
              "topologyKey": {
                "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                "type": "string"
              },
              "whenUnsatisfiable": {
                "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                "type": "string"
              }
            },
            "required": [
              "maxSkew",
              "topologyKey",
              "whenUnsatisfiable"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "strategy": {
          "description": "The deployment strategy to use to replace existing pods with new ones.",
          "properties": {
            "rollingUpdate": {
              "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
              "properties": {
                "maxSurge": {
                  "anyOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "string"
                    }
                  ],
                  "description": "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.",
                  "x-kubernetes-int-or-string": true
                },
                "maxUnavailable": {
                  "anyOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "string"
                    }
                  ],
                  "description": "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.",
                  "x-kubernetes-int-or-string": true
                }
              },
              "type": "object"
            },
            "type": {
              "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
              "type": "string"
            }
          },
          "type": "object"
        },
        "security_context": {
          "description": "Settings to apply to the securityContext field of the api container.",
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        }
      }
    },
    "database": {
      "type": "object",
      "properties": {
        "database_secret": {
          "description": "Secret where the database configuration can be found. Set this to use your own external PostgreSQL database. If not specified, this secret will be generated and Gateway will create a managed postgres pod.",
          "type": "string"
        },
        "postgres_storage_class": {
          "description": "Storage class to use for the PostgreSQL PVC",
          "type": "string"
        },
        "postgres_ssl_mode": {
          "description": "Configure PostgreSQL connection sslmode option. Default: \"prefer\"",
          "type": "string"
        },
        "postgres_data_volume_init": {
          "default": false,
          "description": "Sets permissions on the /var/lib/pgdata/data for postgres container using an init container (not Openshift)",
          "type": "boolean"
        },
        "postgres_keep_pvc_after_upgrade": {
          "description": "Specify whether or not to keep the old PVC after PostgreSQL upgrades",
          "type": "boolean"
        },
        "postgres_init_container_commands": {
          "description": "Customize the postgres init container commands (Non Openshift)",
          "type": "string"
        },
        "postgres_extra_settings": {
          "description": "PostgreSQL configuration settings to be added to postgresql.conf",
          "items": {
            "properties": {
              "setting": {
                "description": "PostgreSQL configuration parameter name",
                "type": "string"
              },
              "value": {
                "description": "PostgreSQL configuration parameter value",
                "type": "string"
              }
            },
            "required": [
              "setting",
              "value"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "idle_disabled": {
          "default": false,
          "description": "When true, prevents the database from being idled",
          "type": "boolean"
        },
        "priority_class": {
          "description": "Assign a pre-existing priority class to the postgres pod",
          "type": "string"
        },
        "resource_requirements": {
          "$ref": "#/definitions/resourceRequirements"
        },
        "storage_requirements": {
          "$ref": "#/definitions/storageRequirements"
        },
        "node_selector": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "NodeSelector for the database pod.",
          "type": "object"
        },
        "tolerations": {
          "description": "Node tolerations for the database pod.",
          "items": {
            "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
            "properties": {
              "effect": {
                "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                "type": "string"
              },
              "key": {
                "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                "type": "string"
              },
              "operator": {
                "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                "type": "string"
              },
              "tolerationSeconds": {
                "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                "format": "int64",
                "type": "integer"
              },
              "value": {
                "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "postgres_extra_args": {
          "description": "(Deprecated, use postgres_extra_settings parameter) Arguments to pass to postgres process",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      }
    },
    "redis": {
      "type": "object",
      "properties": {
        "redis_secret": {
          "description": "Secret where the redis configuration can be found. Set this to use your own external redis instance.",
          "type": "string"
        },
        "eda_redis_secret": {
          "description": "Secret where the EDA redis configuration can be found. Set this to use your own external redis instance for EDA.",
          "type": "string"
        },
        "replicas": {
          "description": "Defines Redis Deployment replicas",
          "format": "int32",
          "type": "integer"
        },
        "resource_requirements": {
          "$ref": "#/definitions/resourceRequirements"
        },
        "node_selector": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "NodeSelector for the Redis pods.",
          "type": "object"
        },
        "tolerations": {
          "description": "Node tolerations for the Redis pods.",
          "items": {
            "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
            "properties": {
              "effect": {
                "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                "type": "string"
              },
              "key": {
                "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                "type": "string"
              },
              "operator": {
                "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                "type": "string"
              },
              "tolerationSeconds": {
                "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                "format": "int64",
                "type": "integer"
              },
              "value": {
                "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "security_context": {
          "description": "Settings to apply to the securityContext field of the redis container.",
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "strategy": {
          "description": "The deployment strategy to use to replace existing pods with new ones.",
          "properties": {
            "rollingUpdate": {
              "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
              "properties": {
                "maxSurge": {
                  "anyOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "string"
                    }
                  ],
                  "description": "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.",
                  "x-kubernetes-int-or-string": true
                },
                "maxUnavailable": {
                  "anyOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "string"
                    }
                  ],
                  "description": "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.",
                  "x-kubernetes-int-or-string": true
                }
              },
              "type": "object"
            },
            "type": {
              "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
              "type": "string"
            }
          },
          "type": "object"
        }
      }
    },
    "controller": {
      "type": "object",
      "properties": {
        "disabled": {
          "type": "boolean"
        },
        "postgres_configuration_secret": {
          "description": "Secret where the database configuration can be found",
          "type": "string"
        },
        "secret_key_secret": {
          "description": "Secret where the secret key can be found",
          "maxLength": 255,
          "type": "string"
        },
        "extra_settings": {
          "description": "Extra settings to specify for AWX",
          "items": {
            "properties": {
              "setting": {
                "type": "string"
              },
              "value": {
                "x-kubernetes-preserve-unknown-fields": true
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "additional_labels": {
          "description": "Additional labels defined on the resource, which should be propagated to child resources",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "admin_email": {
          "description": "The admin user email",
          "type": "string"
        },
        "admin_password_secret": {
          "description": "Secret where the admin password can be found",
          "maxLength": 255,
          "type": "string"
        },
        "admin_user": {
          "default": "admin",
          "description": "Username to use for the admin account",
          "type": "string"
        },
        "affinity": {
          "description": "If specified, the pod's scheduling constraints",
          "properties": {
            "nodeAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "preference": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchFields": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "preference",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "properties": {
                    "nodeSelectorTerms": {
                      "items": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchFields": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "nodeSelectorTerms"
                  ],
                  "type": "object",
                  "x-kubernetes-map-type": "atomic"
                }
              },
              "type": "object"
            },
            "podAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "podAffinityTerm": {
                        "properties": {
                          "labelSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaceSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaces": {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          "topologyKey": {
                            "type": "string"
                          }
                        },
                        "required": [
                          "topologyKey"
                        ],
                        "type": "object"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "podAffinityTerm",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "labelSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaceSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaces": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "topologyKey": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "topologyKey"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }
              },
              "type": "object"
            },
            "podAntiAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "podAffinityTerm": {
                        "properties": {
                          "labelSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaceSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaces": {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          "topologyKey": {
                            "type": "string"
                          }
                        },
                        "required": [
                          "topologyKey"
                        ],
                        "type": "object"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "podAffinityTerm",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "labelSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaceSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaces": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "topologyKey": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "topologyKey"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "annotations": {
          "description": "Common annotations for both Web and Task deployments.",
          "type": "string"
        },
        "api_urlpattern_prefix": {
          "description": "An optional configuration to add a prefix in the API URL path",
          "type": "string"
        },
        "api_version": {
          "description": "apiVersion of the deployment type",
          "type": "string"
        },
        "auto_upgrade": {
          "default": true,
          "description": "Should AWX instances be automatically upgraded when operator gets upgraded",
          "type": "boolean"
        },
        "broadcast_websocket_secret": {
          "description": "Secret where the broadcast websocket secret can be found",
          "maxLength": 255,
          "type": "string"
        },
        "bundle_cacert_secret": {
          "description": "Secret where can be found the trusted Certificate Authority Bundle",
          "type": "string"
        },
        "ca_trust_bundle": {
          "description": "Path where the trusted CA bundle is available",
          "type": "string"
        },
        "control_plane_ee_image": {
          "description": "Registry path to the Execution Environment container image to use on control plane pods",
          "type": "string"
        },
        "control_plane_priority_class": {
          "description": "Assign a preexisting priority class to the control plane pods",
          "type": "string"
        },
        "create_preload_data": {
          "default": true,
          "description": "Whether or not to preload data upon instance creation",
          "type": "boolean"
        },
        "csrf_cookie_secure": {
          "description": "Set csrf cookie secure mode for web",
          "type": "string"
        },
        "deployment_type": {
          "description": "Name of the deployment type",
          "type": "string"
        },
        "development_mode": {
          "description": "If the deployment should be done in development mode",
          "type": "boolean"
        },
        "ee_extra_env": {
          "type": "string"
        },
        "ee_extra_volume_mounts": {
          "description": "Specify volume mounts to be added to Execution container",
          "type": "string"
        },
        "ee_images": {
          "description": "Registry path to the Execution Environment container to use",
          "items": {
            "properties": {
              "image": {
                "type": "string"
              },
              "name": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "ee_pull_credentials_secret": {
          "description": "Secret where pull credentials for registered ees can be found",
          "type": "string"
        },
        "ee_resource_requirements": {
          "description": "Resource requirements for the ee container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "extra_settings_files": {
          "description": "Extra ConfigMaps or Secrets of settings files to specify for AWX",
          "properties": {
            "configmaps": {
              "items": {
                "properties": {
                  "key": {
                    "type": "string"
                  },
                  "name": {
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "secrets": {
              "items": {
                "properties": {
                  "key": {
                    "type": "string"
                  },
                  "name": {
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "extra_volumes": {
          "description": "Specify extra volumes to add to the application pod",
          "type": "string"
        },
        "garbage_collect_secrets": {
          "default": false,
          "description": "Whether or not to remove secrets upon instance removal",
          "type": "boolean"
        },
        "host_aliases": {
          "description": "HostAliases for app containers",
          "items": {
            "properties": {
              "hostnames": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "ip": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "hostname": {
          "description": "(Deprecated) The hostname of the instance",
          "type": "string"
        },
        "idle_deployment": {
          "description": "Scale down deployments to put AWX into an idle state",
          "type": "boolean"
        },
        "image": {
          "description": "Registry path to the application container to use",
          "type": "string"
        },
        "image_pull_policy": {
          "default": "IfNotPresent",
          "description": "The image pull policy",
          "enum": [
            "Always",
            "always",
            "Never",
            "never",
            "IfNotPresent",
            "ifnotpresent"
          ],
          "type": "string"
        },
        "image_pull_secret": {
          "description": "(Deprecated) Image pull secret for app and database containers",
          "type": "string"
        },
        "image_pull_secrets": {
          "description": "Image pull secrets for app and database containers",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "image_version": {
          "description": "Application container image version to use",
          "type": "string"
        },
        "ingress_annotations": {
          "description": "Annotations to add to the Ingress Controller",
          "type": "string"
        },
        "ingress_api_version": {
          "description": "The Ingress API version to use",
          "type": "string"
        },
        "ingress_class_name": {
          "description": "The name of ingress class to use instead of the cluster default.",
          "type": "string"
        },
        "ingress_controller": {
          "description": "Special configuration for specific Ingress Controllers",
          "type": "string"
        },
        "ingress_hosts": {
          "description": "Ingress hostnames of the instance",
          "items": {
            "properties": {
              "hostname": {
                "description": "Hostname of the instance",
                "type": "string"
              },
              "tls_secret": {
                "description": "Secret where the Ingress TLS secret can be found",
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "ingress_path": {
          "description": "The ingress path used to reach the deployed service",
          "type": "string"
        },
        "ingress_path_type": {
          "description": "The ingress path type for the deployed service",
          "type": "string"
        },
        "ingress_tls_secret": {
          "description": "(Deprecated) Secret where the Ingress TLS secret can be found",
          "type": "string"
        },
        "ingress_type": {
          "default": "Route",
          "description": "The ingress type to use to reach the deployed instance",
          "enum": [
            "none",
            "Ingress",
            "ingress",
            "Route",
            "route"
          ],
          "type": "string"
        },
        "init_container_extra_commands": {
          "description": "Extra commands for the init container",
          "type": "string"
        },
        "init_container_extra_volume_mounts": {
          "description": "Specify volume mounts to be added to the init container",
          "type": "string"
        },
        "init_container_image": {
          "description": "Registry path to the init container to use",
          "type": "string"
        },
        "init_container_image_version": {
          "description": "Init container image version to use",
          "type": "string"
        },
        "init_container_resource_requirements": {
          "description": "Resource requirements for the init container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "init_projects_container_image": {
          "description": "Registry path to the init projects container to use",
          "type": "string"
        },
        "ipv6_disabled": {
          "default": false,
          "description": "Disable web container's nginx ipv6 listener",
          "type": "boolean"
        },
        "kind": {
          "description": "Kind of the deployment type",
          "type": "string"
        },
        "ldap_cacert_secret": {
          "description": "(Deprecated) Secret where can be found the LDAP trusted Certificate Authority Bundle",
          "type": "string"
        },
        "ldap_password_secret": {
          "description": "(Deprecated) Secret where can be found the LDAP bind password",
          "type": "string"
        },
        "loadbalancer_class": {
          "default": "",
          "description": "Class of LoadBalancer to use",
          "type": "string"
        },
        "loadbalancer_ip": {
          "default": "",
          "description": "Assign LoadBalancer IP address",
          "type": "string"
        },
        "loadbalancer_port": {
          "default": 80,
          "description": "Port to use for the loadbalancer",
          "type": "integer"
        },
        "loadbalancer_protocol": {
          "default": "http",
          "description": "Protocol to use for the loadbalancer",
          "enum": [
            "http",
            "https"
          ],
          "type": "string"
        },
        "metrics_utility_configmap": {
          "description": "Metrics-Utility ConfigMap",
          "type": "string"
        },
        "metrics_utility_console_enabled": {
          "default": false,
          "description": "Enable metrics utility shipping to Red Hat Hybrid Cloud Console",
          "type": "boolean"
        },
        "metrics_utility_cronjob_gather_schedule": {
          "default": "@hourly",
          "description": "Metrics-Utility Gather Data CronJob Schedule",
          "type": "string"
        },
        "metrics_utility_cronjob_report_schedule": {
          "default": "@monthly",
          "description": "Metrics-Utility Report CronJob Schedule",
          "type": "string"
        },
        "metrics_utility_enabled": {
          "default": false,
          "description": "Enable metrics utility",
          "type": "boolean"
        },
        "metrics_utility_image": {
          "description": "Metrics-Utility Image",
          "type": "string"
        },
        "metrics_utility_image_pull_policy": {
          "description": "Metrics-Utility Image PullPolicy",
          "type": "string"
        },
        "metrics_utility_image_version": {
          "description": "Metrics-Utility Image Version",
          "type": "string"
        },
        "metrics_utility_pvc_claim": {
          "description": "Metrics-Utility PVC Claim",
          "type": "string"
        },
        "metrics_utility_pvc_claim_size": {
          "default": "5Gi",
          "description": "Metrics-Utility PVC Claim Size",
          "type": "string"
        },
        "metrics_utility_pvc_claim_storage_class": {
          "description": "Metrics-Utility PVC Claim Storage Class",
          "type": "string"
        },
        "metrics_utility_secret": {
          "description": "Metrics-Utility Secret",
          "type": "string"
        },
        "metrics_utility_ship_target": {
          "description": "Metrics-Utility Ship Target",
          "type": "string"
        },
        "nginx_client_max_body_size": {
          "description": "Sets the maximum allowed size of the client request body in megabytes (defaults to 5M)",
          "type": "integer"
        },
        "nginx_listen_queue_size": {
          "description": "Set the socket listen queue size for nginx (defaults to same as uwsgi)",
          "type": "integer"
        },
        "nginx_worker_connections": {
          "description": "Set the number of connections per worker for nginx",
          "type": "integer"
        },
        "nginx_worker_cpu_affinity": {
          "description": "Set the CPU affinity for nginx workers",
          "type": "string"
        },
        "nginx_worker_processes": {
          "description": "Set the number of workers for nginx",
          "type": "integer"
        },
        "no_log": {
          "default": true,
          "description": "Configure no_log for no_log tasks",
          "type": "boolean"
        },
        "node_selector": {
          "description": "nodeSelector for the pods",
          "type": "string"
        },
        "nodeport_port": {
          "description": "Port to use for the nodeport",
          "type": "integer"
        },
        "old_postgres_configuration_secret": {
          "description": "Secret where the old database configuration can be found for data migration",
          "maxLength": 255,
          "type": "string"
        },
        "pg_dump_suffix": {
          "description": "Additional parameters for the pg_dump command during a migration",
          "type": "string"
        },
        "postgres_annotations": {
          "description": "Annotations to add to the Postgres deployment.",
          "type": "string"
        },
        "postgres_data_volume_init": {
          "description": "Sets permissions on the /var/lib/pgdata/data for postgres container using an init container (not Openshift)",
          "type": "boolean"
        },
        "postgres_extra_args": {
          "description": "(Deprecated, use postgres_extra_settings parameter) Define postgres configuration arguments to use",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "postgres_extra_settings": {
          "description": "PostgreSQL configuration settings to be added to postgresql.conf",
          "items": {
            "properties": {
              "setting": {
                "description": "PostgreSQL configuration parameter name",
                "type": "string"
              },
              "value": {
                "description": "PostgreSQL configuration parameter value",
                "type": "string"
              }
            },
            "required": [
              "setting",
              "value"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "postgres_extra_volume_mounts": {
          "description": "Specify volume mounts to be added to Postgres container",
          "type": "string"
        },
        "postgres_extra_volumes": {
          "description": "Specify extra volumes to add to the application pod",
          "type": "string"
        },
        "postgres_image": {
          "description": "Registry path to the PostgreSQL container to use",
          "type": "string"
        },
        "postgres_image_version": {
          "description": "PostgreSQL container image version to use",
          "type": "string"
        },
        "postgres_init_container_commands": {
          "description": "Customize the postgres init container commands (Non Openshift)",
          "type": "string"
        },
        "postgres_init_container_resource_requirements": {
          "description": "(Deprecated, use postgres_resource_requirements parameter) Resource requirements for the postgres init container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "postgres_keep_pvc_after_upgrade": {
          "description": "Specify whether or not to keep the old PVC after PostgreSQL upgrades",
          "type": "boolean"
        },
        "postgres_keepalives": {
          "default": true,
          "description": "Controls whether client-side TCP keepalives are used for Postgres connections.",
          "type": "boolean"
        },
        "postgres_keepalives_count": {
          "default": 5,
          "description": "Controls the number of TCP keepalives that can be lost before the client's connection to the server is considered dead.",
          "format": "int32",
          "type": "integer"
        },
        "postgres_keepalives_idle": {
          "default": 5,
          "description": "Controls the number of seconds of inactivity after which TCP should send a keepalive message to the server.",
          "format": "int32",
          "type": "integer"
        },
        "postgres_keepalives_interval": {
          "default": 5,
          "description": "Controls the number of seconds after which a TCP keepalive message that is not acknowledged by the server should be retransmitted.",
          "format": "int32",
          "type": "integer"
        },
        "postgres_label_selector": {
          "description": "Label selector used to identify postgres pod for data migration",
          "type": "string"
        },
        "postgres_priority_class": {
          "description": "Assign a preexisting priority class to the postgres pod",
          "type": "string"
        },
        "postgres_resource_requirements": {
          "description": "Resource requirements for the PostgreSQL container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "postgres_security_context_settings": {
          "description": "Key/values that will be set under the pod-level securityContext field",
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "postgres_selector": {
          "description": "nodeSelector for the Postgres pods",
          "type": "string"
        },
        "postgres_storage_class": {
          "description": "Storage class to use for the PostgreSQL PVC",
          "type": "string"
        },
        "postgres_storage_requirements": {
          "description": "Storage requirements for the PostgreSQL container",
          "properties": {
            "limits": {
              "properties": {
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "postgres_tolerations": {
          "description": "node tolerations for the Postgres pods",
          "type": "string"
        },
        "projects_existing_claim": {
          "description": "PersistentVolumeClaim to mount /var/lib/projects directory",
          "type": "string"
        },
        "projects_persistence": {
          "default": false,
          "description": "Whether or not the /var/lib/projects directory will be persistent",
          "type": "boolean"
        },
        "projects_storage_access_mode": {
          "default": "ReadWriteMany",
          "description": "AccessMode for the /var/lib/projects PersistentVolumeClaim",
          "type": "string"
        },
        "projects_storage_class": {
          "description": "Storage class for the /var/lib/projects PersistentVolumeClaim",
          "type": "string"
        },
        "projects_storage_size": {
          "default": "8Gi",
          "description": "Size for the /var/lib/projects PersistentVolumeClaim",
          "type": "string"
        },
        "projects_use_existing_claim": {
          "description": "Using existing PersistentVolumeClaim",
          "enum": [
            "_Yes_",
            "_No_"
          ],
          "type": "string"
        },
        "public_base_url": {
          "description": "Public base URL",
          "type": "string"
        },
        "receptor_log_level": {
          "description": "Set log level of receptor service",
          "type": "string"
        },
        "redis_capabilities": {
          "description": "Redis container capabilities",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "redis_image": {
          "description": "Registry path to the redis container to use",
          "type": "string"
        },
        "redis_image_version": {
          "description": "Redis container image version to use",
          "type": "string"
        },
        "redis_resource_requirements": {
          "description": "Resource requirements for the redis container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "replicas": {
          "default": 1,
          "description": "Number of instance replicas",
          "format": "int32",
          "type": "integer"
        },
        "route_api_version": {
          "description": "The route API version to use",
          "type": "string"
        },
        "route_host": {
          "description": "The DNS to use to points to the instance",
          "type": "string"
        },
        "route_tls_secret": {
          "description": "Secret where the TLS related credentials are stored",
          "type": "string"
        },
        "route_tls_termination_mechanism": {
          "default": "Edge",
          "description": "The secure TLS termination mechanism to use",
          "enum": [
            "Edge",
            "edge",
            "Passthrough",
            "passthrough"
          ],
          "type": "string"
        },
        "rsyslog_args": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "rsyslog_command": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "rsyslog_extra_env": {
          "type": "string"
        },
        "rsyslog_extra_volume_mounts": {
          "description": "Specify volume mounts to be added to the Rsyslog container",
          "type": "string"
        },
        "rsyslog_resource_requirements": {
          "description": "Resource requirements for the rsyslog container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "security_context_settings": {
          "description": "Key/values that will be set under the pod-level securityContext field",
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "service_account_annotations": {
          "description": "ServiceAccount annotations",
          "type": "string"
        },
        "service_annotations": {
          "description": "Annotations to add to the service",
          "type": "string"
        },
        "service_labels": {
          "description": "Additional labels to apply to the service",
          "type": "string"
        },
        "service_type": {
          "description": "The service type to be used on the deployed instance",
          "enum": [
            "LoadBalancer",
            "loadbalancer",
            "ClusterIP",
            "clusterip",
            "NodePort",
            "nodeport"
          ],
          "type": "string"
        },
        "session_cookie_secure": {
          "description": "Set session cookie secure mode for web",
          "type": "string"
        },
        "set_self_labels": {
          "default": true,
          "description": "Maintain some of the recommended `app.kubernetes.io/*` labels on the resource (self)",
          "type": "boolean"
        },
        "task_affinity": {
          "description": "If specified, the pod's scheduling constraints",
          "properties": {
            "nodeAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "preference": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchFields": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "preference",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "properties": {
                    "nodeSelectorTerms": {
                      "items": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchFields": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "nodeSelectorTerms"
                  ],
                  "type": "object",
                  "x-kubernetes-map-type": "atomic"
                }
              },
              "type": "object"
            },
            "podAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "podAffinityTerm": {
                        "properties": {
                          "labelSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaceSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaces": {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          "topologyKey": {
                            "type": "string"
                          }
                        },
                        "required": [
                          "topologyKey"
                        ],
                        "type": "object"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "podAffinityTerm",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "labelSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaceSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaces": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "topologyKey": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "topologyKey"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }
              },
              "type": "object"
            },
            "podAntiAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "podAffinityTerm": {
                        "properties": {
                          "labelSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaceSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaces": {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          "topologyKey": {
                            "type": "string"
                          }
                        },
                        "required": [
                          "topologyKey"
                        ],
                        "type": "object"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "podAffinityTerm",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "labelSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaceSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaces": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "topologyKey": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "topologyKey"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "task_annotations": {
          "description": "Task deployment annotations. This will override the general annotations parameter for the Task deployment.",
          "type": "string"
        },
        "task_args": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "task_command": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "task_extra_env": {
          "type": "string"
        },
        "task_extra_volume_mounts": {
          "description": "Specify volume mounts to be added to Task container",
          "type": "string"
        },
        "task_liveness_failure_threshold": {
          "default": 3,
          "description": "Number of consecutive failure events to identify failure of task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_liveness_initial_delay": {
          "default": 5,
          "description": "Initial delay before starting liveness checks on task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_liveness_period": {
          "default": 0,
          "description": "Time period in seconds between each liveness check for the task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_liveness_timeout": {
          "default": 1,
          "description": "Number of seconds to wait for a probe response from task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_manage_replicas": {
          "default": true,
          "description": "Enables operator control of replicas count for the task deployment when set to 'true'",
          "type": "boolean"
        },
        "task_node_selector": {
          "description": "nodeSelector for the task pods",
          "type": "string"
        },
        "task_privileged": {
          "default": false,
          "description": "If a privileged security context should be enabled",
          "type": "boolean"
        },
        "task_readiness_failure_threshold": {
          "default": 3,
          "description": "Number of consecutive failure events to identify failure of task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_readiness_initial_delay": {
          "default": 20,
          "description": "Initial delay before starting readiness checks on task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_readiness_period": {
          "default": 0,
          "description": "Time period in seconds between each readiness check for the task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_readiness_timeout": {
          "default": 1,
          "description": "Number of seconds to wait for a probe response from task pod",
          "format": "int32",
          "type": "integer"
        },
        "task_replicas": {
          "description": "Number of task instance replicas",
          "format": "int32",
          "type": "integer"
        },
        "task_resource_requirements": {
          "description": "Resource requirements for the task container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "task_tolerations": {
          "description": "node tolerations for the task pods",
          "type": "string"
        },
        "task_topology_spread_constraints": {
          "description": "topology rule(s) for the task pods",
          "type": "string"
        },
        "termination_grace_period_seconds": {
          "description": "Optional duration in seconds pods needs to terminate gracefully",
          "format": "int32",
          "type": "integer"
        },
        "tolerations": {
          "description": "node tolerations for the pods",
          "type": "string"
        },
        "topology_spread_constraints": {
          "description": "topology rule(s) for the pods",
          "type": "string"
        },
        "uwsgi_listen_queue_size": {
          "description": "Set the socket listen queue size for uwsgi",
          "type": "integer"
        },
        "uwsgi_processes": {
          "description": "Set the number of uwsgi processes to run in a web container",
          "type": "integer"
        },
        "web_affinity": {
          "description": "If specified, the pod's scheduling constraints",
          "properties": {
            "nodeAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "preference": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchFields": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "preference",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "properties": {
                    "nodeSelectorTerms": {
                      "items": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchFields": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "nodeSelectorTerms"
                  ],
                  "type": "object",
                  "x-kubernetes-map-type": "atomic"
                }
              },
              "type": "object"
            },
            "podAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "podAffinityTerm": {
                        "properties": {
                          "labelSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaceSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaces": {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          "topologyKey": {
                            "type": "string"
                          }
                        },
                        "required": [
                          "topologyKey"
                        ],
                        "type": "object"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "podAffinityTerm",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "labelSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaceSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaces": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "topologyKey": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "topologyKey"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }
              },
              "type": "object"
            },
            "podAntiAffinity": {
              "properties": {
                "preferredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "podAffinityTerm": {
                        "properties": {
                          "labelSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaceSelector": {
                            "properties": {
                              "matchExpressions": {
                                "items": {
                                  "properties": {
                                    "key": {
                                      "type": "string"
                                    },
                                    "operator": {
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object"
                                },
                                "type": "array"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic"
                          },
                          "namespaces": {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          "topologyKey": {
                            "type": "string"
                          }
                        },
                        "required": [
                          "topologyKey"
                        ],
                        "type": "object"
                      },
                      "weight": {
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "podAffinityTerm",
                      "weight"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "items": {
                    "properties": {
                      "labelSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaceSelector": {
                        "properties": {
                          "matchExpressions": {
                            "items": {
                              "properties": {
                                "key": {
                                  "type": "string"
                                },
                                "operator": {
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic"
                      },
                      "namespaces": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "topologyKey": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "topologyKey"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "web_annotations": {
          "description": "Web deployment annotations. This will override the general annotations parameter for the Web deployment.",
          "type": "string"
        },
        "web_args": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "web_command": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "web_extra_env": {
          "type": "string"
        },
        "web_extra_volume_mounts": {
          "description": "Specify volume mounts to be added to the Web container",
          "type": "string"
        },
        "web_liveness_failure_threshold": {
          "default": 3,
          "description": "Number of consecutive failure events to identify failure of web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_liveness_initial_delay": {
          "default": 5,
          "description": "Initial delay before starting liveness checks on web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_liveness_period": {
          "default": 0,
          "description": "Time period in seconds between each liveness check for the web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_liveness_timeout": {
          "default": 1,
          "description": "Number of seconds to wait for a probe response from web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_manage_replicas": {
          "default": true,
          "description": "Enables operator control of replicas count for the web deployment when set to 'true'",
          "type": "boolean"
        },
        "web_node_selector": {
          "description": "nodeSelector for the web pods",
          "type": "string"
        },
        "web_readiness_failure_threshold": {
          "default": 3,
          "description": "Number of consecutive failure events to identify failure of web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_readiness_initial_delay": {
          "default": 20,
          "description": "Initial delay before starting readiness checks on web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_readiness_period": {
          "default": 0,
          "description": "Time period in seconds between each readiness check for the web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_readiness_timeout": {
          "default": 1,
          "description": "Number of seconds to wait for a probe response from web pod",
          "format": "int32",
          "type": "integer"
        },
        "web_replicas": {
          "description": "Number of web instance replicas",
          "format": "int32",
          "type": "integer"
        },
        "web_resource_requirements": {
          "description": "Resource requirements for the web container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "ephemeral-storage": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "web_tolerations": {
          "description": "node tolerations for the web pods",
          "type": "string"
        },
        "web_topology_spread_constraints": {
          "description": "topology rule(s) for the web pods",
          "type": "string"
        }
      }
    },
    "eda": {
      "type": "object",
      "properties": {
        "disabled": {
          "type": "boolean"
        },
        "automation_server_url": {
          "description": "URL of the Automation Controller instance to run ansible jobs against",
          "type": "string"
        },
        "extra_settings": {
          "description": "Environment variables to configure the application-level settings",
          "items": {
            "properties": {
              "setting": {
                "type": "string"
              },
              "value": {
                "x-kubernetes-preserve-unknown-fields": true
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "db_fields_encryption_secret": {
          "description": "Secret where the DB fields encryption key can be found. If not specified, one will be generated.",
          "type": "string"
        },
        "activation_worker": {
          "description": "Defines desired state of eda-activation-worker resources",
          "properties": {
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "replicas": {
              "default": 2,
              "description": "Size is the size of number of eda-activation-worker replicas. Default: 2",
              "format": "int32",
              "minimum": 0,
              "nullable": true,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the eda-activation-worker container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "topology_spread_constraints": {
              "description": "Topology rule(s) for the pods.",
              "items": {
                "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
                "properties": {
                  "labelSelector": {
                    "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                    "properties": {
                      "matchExpressions": {
                        "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                        "items": {
                          "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                          "properties": {
                            "key": {
                              "description": "key is the label key that the selector applies to.",
                              "type": "string"
                            },
                            "operator": {
                              "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                              "type": "string"
                            },
                            "values": {
                              "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "key",
                            "operator"
                          ],
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "matchLabels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic"
                  },
                  "matchLabelKeys": {
                    "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "maxSkew": {
                    "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.",
                    "format": "int32",
                    "type": "integer"
                  },
                  "minDomains": {
                    "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                    "format": "int32",
                    "type": "integer"
                  },
                  "nodeAffinityPolicy": {
                    "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "nodeTaintsPolicy": {
                    "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "topologyKey": {
                    "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                    "type": "string"
                  },
                  "whenUnsatisfiable": {
                    "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                    "type": "string"
                  }
                },
                "required": [
                  "maxSkew",
                  "topologyKey",
                  "whenUnsatisfiable"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "additional_labels": {
          "description": "Additional labels defined on the resource, which should be propagated to child resources",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "admin_password_secret": {
          "description": "Secret where the admin password can be found. If not specified, one will be generated.",
          "type": "string"
        },
        "admin_user": {
          "default": "admin",
          "description": "Username to use for the admin account",
          "type": "string"
        },
        "api": {
          "description": "Defines desired state of eda-api resources",
          "properties": {
            "gunicorn_workers": {
              "default": 2,
              "description": "The number of gunicorn workers for the api. Default: 2",
              "format": "int32",
              "minimum": 1,
              "type": "integer"
            },
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "replicas": {
              "default": 1,
              "description": "Size is the size of number of eda-api replicas. Default: 1",
              "format": "int32",
              "nullable": true,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the eda-api container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "topology_spread_constraints": {
              "description": "Topology rule(s) for the pods.",
              "items": {
                "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
                "properties": {
                  "labelSelector": {
                    "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                    "properties": {
                      "matchExpressions": {
                        "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                        "items": {
                          "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                          "properties": {
                            "key": {
                              "description": "key is the label key that the selector applies to.",
                              "type": "string"
                            },
                            "operator": {
                              "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                              "type": "string"
                            },
                            "values": {
                              "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "key",
                            "operator"
                          ],
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "matchLabels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic"
                  },
                  "matchLabelKeys": {
                    "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "maxSkew": {
                    "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.",
                    "format": "int32",
                    "type": "integer"
                  },
                  "minDomains": {
                    "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                    "format": "int32",
                    "type": "integer"
                  },
                  "nodeAffinityPolicy": {
                    "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "nodeTaintsPolicy": {
                    "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "topologyKey": {
                    "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                    "type": "string"
                  },
                  "whenUnsatisfiable": {
                    "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                    "type": "string"
                  }
                },
                "required": [
                  "maxSkew",
                  "topologyKey",
                  "whenUnsatisfiable"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "automation_server_ssl_verify": {
          "description": "SSL Verify (yes, no) for the Automation Controller instance",
          "type": "string"
        },
        "bundle_cacert_secret": {
          "description": "Secret where the trusted Certificate Authority Bundle is stored",
          "type": "string"
        },
        "database": {
          "type": "object",
          "properties": {
            "database_secret": {
              "description": "Secret where the database configuration can be found. Set this to us your own external PostgreSQL database. If not specified, this secret will be generated and EDA will not create a managed postgres pod.",
              "type": "string"
            },
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the database pod.",
              "type": "object"
            },
            "postgres_data_volume_init": {
              "default": false,
              "description": "Sets permissions on the /var/lib/pgdata/data for postgres container using an init container (not Openshift)",
              "type": "boolean"
            },
            "postgres_extra_args": {
              "description": "(Deprecated, use postgres_extra_settings parameter) Arguments to pass to postgres process",
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "postgres_extra_settings": {
              "description": "PostgreSQL configuration settings to be added to postgresql.conf",
              "items": {
                "properties": {
                  "setting": {
                    "description": "PostgreSQL configuration parameter name",
                    "type": "string"
                  },
                  "value": {
                    "description": "PostgreSQL configuration parameter value",
                    "type": "string"
                  }
                },
                "required": [
                  "setting",
                  "value"
                ],
                "type": "object"
              },
              "type": "array"
            },
            "postgres_init_container_commands": {
              "description": "Customize the postgres init container commands (Non Openshift)",
              "type": "string"
            },
            "postgres_keep_pvc_after_upgrade": {
              "description": "Specify whether or not to keep the old PVC after PostgreSQL upgrades",
              "type": "boolean"
            },
            "postgres_ssl_mode": {
              "description": "Configure PostgreSQL connection sslmode option. Default: \"prefer\"",
              "type": "string"
            },
            "postgres_storage_class": {
              "description": "Storage class to use for the PostgreSQL PVC",
              "type": "string"
            },
            "priority_class": {
              "description": "Assign a pre-existing priority class to the postgres pod",
              "type": "string"
            },
            "resource_requirements": {
              "description": "Resource requirements for the database container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "storage_requirements": {
              "description": "Storage requirements for the PostgreSQL container",
              "properties": {
                "limits": {
                  "properties": {
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "requests": {
                  "properties": {
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the database pod.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            }
          }
        },
        "default_worker": {
          "description": "Defines desired state of eda-default-worker resources",
          "properties": {
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "replicas": {
              "default": 2,
              "description": "Size is the size of number of eda-default-worker replicas. Default: 2",
              "format": "int32",
              "minimum": 0,
              "nullable": true,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the eda-default-worker container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "topology_spread_constraints": {
              "description": "Topology rule(s) for the pods.",
              "items": {
                "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
                "properties": {
                  "labelSelector": {
                    "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                    "properties": {
                      "matchExpressions": {
                        "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                        "items": {
                          "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                          "properties": {
                            "key": {
                              "description": "key is the label key that the selector applies to.",
                              "type": "string"
                            },
                            "operator": {
                              "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                              "type": "string"
                            },
                            "values": {
                              "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "key",
                            "operator"
                          ],
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "matchLabels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic"
                  },
                  "matchLabelKeys": {
                    "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "maxSkew": {
                    "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.",
                    "format": "int32",
                    "type": "integer"
                  },
                  "minDomains": {
                    "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                    "format": "int32",
                    "type": "integer"
                  },
                  "nodeAffinityPolicy": {
                    "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "nodeTaintsPolicy": {
                    "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "topologyKey": {
                    "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                    "type": "string"
                  },
                  "whenUnsatisfiable": {
                    "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                    "type": "string"
                  }
                },
                "required": [
                  "maxSkew",
                  "topologyKey",
                  "whenUnsatisfiable"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "event_stream": {
          "description": "Defines desired state of Event Stream resources",
          "properties": {
            "gunicorn_workers": {
              "default": 2,
              "description": "The number of gunicorn workers for the api. Default: 2",
              "format": "int32",
              "minimum": 1,
              "type": "integer"
            },
            "mtls": {
              "default": true,
              "description": "Enable mTLS for event-stream.",
              "type": "boolean"
            },
            "mtls_prefix": {
              "description": "Prefix for the Event Stream mTLS URL",
              "type": "string"
            },
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "prefix": {
              "description": "Prefix for the Event Stream URL",
              "type": "string"
            },
            "replicas": {
              "default": 1,
              "description": "Size is the size of number of eda-worker replicas. Default: 1",
              "format": "int32",
              "nullable": true,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the eda-worker container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "topology_spread_constraints": {
              "description": "Topology rule(s) for the pods.",
              "items": {
                "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
                "properties": {
                  "labelSelector": {
                    "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                    "properties": {
                      "matchExpressions": {
                        "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                        "items": {
                          "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                          "properties": {
                            "key": {
                              "description": "key is the label key that the selector applies to.",
                              "type": "string"
                            },
                            "operator": {
                              "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                              "type": "string"
                            },
                            "values": {
                              "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "key",
                            "operator"
                          ],
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "matchLabels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic"
                  },
                  "matchLabelKeys": {
                    "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "maxSkew": {
                    "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.",
                    "format": "int32",
                    "type": "integer"
                  },
                  "minDomains": {
                    "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                    "format": "int32",
                    "type": "integer"
                  },
                  "nodeAffinityPolicy": {
                    "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "nodeTaintsPolicy": {
                    "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "topologyKey": {
                    "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                    "type": "string"
                  },
                  "whenUnsatisfiable": {
                    "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                    "type": "string"
                  }
                },
                "required": [
                  "maxSkew",
                  "topologyKey",
                  "whenUnsatisfiable"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "force_drop_db": {
          "description": "Force drop the database before restoring. USE WITH CAUTION!",
          "type": "boolean"
        },
        "hostname": {
          "description": "The hostname of the instance",
          "type": "string"
        },
        "idle_deployment": {
          "description": "Scale down deployments to put EDA into an idle state",
          "type": "boolean"
        },
        "image": {
          "description": "Registry path to API container image to use",
          "type": "string"
        },
        "image_pull_policy": {
          "default": "IfNotPresent",
          "description": "The image pull policy",
          "enum": [
            "Always",
            "always",
            "Never",
            "never",
            "IfNotPresent",
            "ifnotpresent"
          ],
          "type": "string"
        },
        "image_pull_secrets": {
          "description": "Image pull secrets for app and database containers",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "image_version": {
          "description": "API container image tag or version to use",
          "type": "string"
        },
        "image_web": {
          "description": "Registry path to UI container image to use",
          "type": "string"
        },
        "image_web_version": {
          "description": "UI container image tag or version to use",
          "type": "string"
        },
        "ingress_annotations": {
          "description": "Annotations to add to the Ingress Controller",
          "type": "string"
        },
        "ingress_api_version": {
          "description": "The Ingress API version to use",
          "type": "string"
        },
        "ingress_class_name": {
          "description": "The name of ingress class to use instead of the cluster default.",
          "type": "string"
        },
        "ingress_path": {
          "description": "The ingress path used to reach the deployed service",
          "type": "string"
        },
        "ingress_path_type": {
          "description": "The ingress path type for the deployed service",
          "type": "string"
        },
        "ingress_tls_secret": {
          "description": "Secret where the Ingress TLS secret can be found",
          "type": "string"
        },
        "ingress_type": {
          "default": "Route",
          "description": "The ingress type to use to reach the deployed instance",
          "enum": [
            "None",
            "none",
            "Ingress",
            "ingress",
            "Route",
            "route"
          ],
          "type": "string"
        },
        "ipv6_disabled": {
          "description": "Disable UI container's nginx ipv6 listener",
          "type": "boolean"
        },
        "loadbalancer_port": {
          "description": "Port to use for the loadbalancer",
          "type": "integer"
        },
        "loadbalancer_protocol": {
          "description": "Protocol to use for the loadbalancer",
          "enum": [
            "http",
            "https"
          ],
          "type": "string"
        },
        "no_log": {
          "default": true,
          "description": "Configure no_log for no log tasks",
          "type": "boolean"
        },
        "nodeport_port": {
          "description": "Port to use for the nodeport",
          "type": "integer"
        },
        "old_postgres_configuration_secret": {
          "description": "Secret where the old database configuration can be found for data migration",
          "maxLength": 255,
          "type": "string"
        },
        "pg_dump_suffix": {
          "description": "Additional parameters for the pg_dump command during a migration",
          "type": "string"
        },
        "postgres_image": {
          "description": "Registry path to the PostgreSQL container to use",
          "type": "string"
        },
        "postgres_image_version": {
          "description": "PostgreSQL container image version to use",
          "type": "string"
        },
        "postgres_label_selector": {
          "description": "Label selector used to identify postgres pod for data migration",
          "type": "string"
        },
        "public_base_url": {
          "default": "",
          "description": "Public base URL for EDA",
          "type": "string"
        },
        "redis": {
          "description": "Defines desired state of cache resources",
          "properties": {
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "redis_secret": {
              "description": "Secret where the redis configuration can be found. Set this to us your own external Redis cache. If not specified, this secret will be generated and EDA will not create a managed Redis pod.",
              "type": "string"
            },
            "replicas": {
              "default": 1,
              "description": "Defines Redis Deployment replicas",
              "format": "int32",
              "maximum": 1,
              "minimum": 0,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the Redis container",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "redis_image": {
          "description": "Registry path to Redis container image to use",
          "type": "string"
        },
        "redis_image_version": {
          "description": "Redis container image tag or version to use",
          "type": "string"
        },
        "route_api_version": {
          "description": "The route API version to use",
          "type": "string"
        },
        "route_host": {
          "description": "The DNS to use to points to the instance",
          "type": "string"
        },
        "route_tls_secret": {
          "description": "Secret where the TLS related credentials are stored",
          "type": "string"
        },
        "route_tls_termination_mechanism": {
          "description": "The secure TLS termination mechanism to use",
          "enum": [
            "Edge",
            "edge",
            "Passthrough",
            "passthrough"
          ],
          "type": "string"
        },
        "scheduler": {
          "description": "Defines desired state of eda-scheduler resources",
          "properties": {
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "replicas": {
              "default": 2,
              "description": "Size is the size of number of eda-scheduler replicas. Default: 2",
              "format": "int32",
              "minimum": 0,
              "nullable": true,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the eda-scheduler container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "topology_spread_constraints": {
              "description": "Topology rule(s) for the pods.",
              "items": {
                "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
                "properties": {
                  "labelSelector": {
                    "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                    "properties": {
                      "matchExpressions": {
                        "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                        "items": {
                          "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                          "properties": {
                            "key": {
                              "description": "key is the label key that the selector applies to.",
                              "type": "string"
                            },
                            "operator": {
                              "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                              "type": "string"
                            },
                            "values": {
                              "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "key",
                            "operator"
                          ],
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "matchLabels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic"
                  },
                  "matchLabelKeys": {
                    "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "maxSkew": {
                    "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.",
                    "format": "int32",
                    "type": "integer"
                  },
                  "minDomains": {
                    "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                    "format": "int32",
                    "type": "integer"
                  },
                  "nodeAffinityPolicy": {
                    "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "nodeTaintsPolicy": {
                    "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "topologyKey": {
                    "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                    "type": "string"
                  },
                  "whenUnsatisfiable": {
                    "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                    "type": "string"
                  }
                },
                "required": [
                  "maxSkew",
                  "topologyKey",
                  "whenUnsatisfiable"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "service_account_annotations": {
          "description": "ServiceAccount annotations",
          "type": "string"
        },
        "service_type": {
          "description": "The service type to be used on the deployed instance",
          "enum": [
            "LoadBalancer",
            "loadbalancer",
            "ClusterIP",
            "clusterip",
            "NodePort",
            "nodeport"
          ],
          "type": "string"
        },
        "set_self_labels": {
          "description": "Maintain some of the recommended `app.kubernetes.io/*` labels on the resource (self)",
          "type": "boolean"
        },
        "ui": {
          "description": "Defines desired state of eda-ui resources",
          "properties": {
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "replicas": {
              "default": 1,
              "description": "Size is the size of number of eda-ui replicas. Default: 1",
              "format": "int32",
              "minimum": 0,
              "nullable": true,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the eda-ui container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "topology_spread_constraints": {
              "description": "Topology rule(s) for the pods.",
              "items": {
                "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
                "properties": {
                  "labelSelector": {
                    "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                    "properties": {
                      "matchExpressions": {
                        "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                        "items": {
                          "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                          "properties": {
                            "key": {
                              "description": "key is the label key that the selector applies to.",
                              "type": "string"
                            },
                            "operator": {
                              "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                              "type": "string"
                            },
                            "values": {
                              "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "key",
                            "operator"
                          ],
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "matchLabels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic"
                  },
                  "matchLabelKeys": {
                    "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "maxSkew": {
                    "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.",
                    "format": "int32",
                    "type": "integer"
                  },
                  "minDomains": {
                    "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                    "format": "int32",
                    "type": "integer"
                  },
                  "nodeAffinityPolicy": {
                    "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "nodeTaintsPolicy": {
                    "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "topologyKey": {
                    "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                    "type": "string"
                  },
                  "whenUnsatisfiable": {
                    "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                    "type": "string"
                  }
                },
                "required": [
                  "maxSkew",
                  "topologyKey",
                  "whenUnsatisfiable"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        },
        "ui_disabled": {
          "description": "Disable the UI for a headless EDA deployment (only API endpoints)",
          "type": "boolean"
        },
        "worker": {
          "description": "(Deprecated) Defines desired state of eda-worker resources",
          "properties": {
            "node_selector": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "NodeSelector for the EDA pods.",
              "type": "object"
            },
            "replicas": {
              "default": 2,
              "description": "Size is the size of number of eda-worker replicas. Default: 2",
              "format": "int32",
              "minimum": 0,
              "nullable": true,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the eda-worker container.",
              "properties": {
                "claims": {
                  "description": "Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. \n This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. \n This field is immutable.",
                  "items": {
                    "description": "ResourceClaim references one entry in PodSpec.ResourceClaims.",
                    "properties": {
                      "name": {
                        "description": "Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "type": "object"
                  },
                  "type": "array",
                  "x-kubernetes-list-map-keys": [
                    "name"
                  ],
                  "x-kubernetes-list-type": "map"
                },
                "limits": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                },
                "requests": {
                  "additionalProperties": {
                    "anyOf": [
                      {
                        "type": "integer"
                      },
                      {
                        "type": "string"
                      }
                    ],
                    "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                    "x-kubernetes-int-or-string": true
                  },
                  "description": "Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "tolerations": {
              "description": "Node tolerations for the EDA pods.",
              "items": {
                "description": "The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.",
                "properties": {
                  "effect": {
                    "description": "Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.",
                    "type": "string"
                  },
                  "key": {
                    "description": "Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.",
                    "type": "string"
                  },
                  "operator": {
                    "description": "Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category.",
                    "type": "string"
                  },
                  "tolerationSeconds": {
                    "description": "TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system.",
                    "format": "int64",
                    "type": "integer"
                  },
                  "value": {
                    "description": "Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "topology_spread_constraints": {
              "description": "Topology rule(s) for the pods.",
              "items": {
                "description": "TopologySpreadConstraint specifies how to spread matching pods among the given topology.",
                "properties": {
                  "labelSelector": {
                    "description": "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain.",
                    "properties": {
                      "matchExpressions": {
                        "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                        "items": {
                          "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                          "properties": {
                            "key": {
                              "description": "key is the label key that the selector applies to.",
                              "type": "string"
                            },
                            "operator": {
                              "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                              "type": "string"
                            },
                            "values": {
                              "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "key",
                            "operator"
                          ],
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "matchLabels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic"
                  },
                  "matchLabelKeys": {
                    "description": "MatchLabelKeys is a set of pod label keys to select the pods over which spreading will be calculated. The keys are used to lookup values from the incoming pod labels, those key-value labels are ANDed with labelSelector to select the group of existing pods over which spreading will be calculated for the incoming pod. Keys that don't exist in the incoming pod labels will be ignored. A null or empty list means only match against labelSelector.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "maxSkew": {
                    "description": "MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed.",
                    "format": "int32",
                    "type": "integer"
                  },
                  "minDomains": {
                    "description": "MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats \"global minimum\" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. \n For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so \"global minimum\" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. \n This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).",
                    "format": "int32",
                    "type": "integer"
                  },
                  "nodeAffinityPolicy": {
                    "description": "NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations. \n If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "nodeTaintsPolicy": {
                    "description": "NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included. \n If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.",
                    "type": "string"
                  },
                  "topologyKey": {
                    "description": "TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a \"bucket\", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is \"kubernetes.io/hostname\", each Node is a domain of that topology. And, if TopologyKey is \"topology.kubernetes.io/zone\", each zone is a domain of that topology. It's a required field.",
                    "type": "string"
                  },
                  "whenUnsatisfiable": {
                    "description": "WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered \"Unsatisfiable\" for an incoming pod if and only if every possible node assignment for that pod would violate \"MaxSkew\" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field.",
                    "type": "string"
                  }
                },
                "required": [
                  "maxSkew",
                  "topologyKey",
                  "whenUnsatisfiable"
                ],
                "type": "object"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      }
    },
    "secretProvider": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "",
            "vso"
          ]
        },
        "vso": {
          "type": "object",
          "properties": {
            "connection": {
              "type": "object",
              "properties": {
                "address": {
                  "type": "string"
                },
                "vaultNamespace": {
                  "type": "string"
                },
                "skipTLSVerify": {
                  "default": false,
                  "type": "boolean"
                },
                "caCertSecretRef": {
                  "type": "string"
                }
              }
            },
            "auth": {
              "type": "object",
              "properties": {
                "appRole": {
                  "type": "object",
                  "required": [
                    "roleId",
                    "secretRef",
                    "mount"
                  ],
                  "properties": {
                    "roleId": {
                      "type": "string"
                    },
                    "secretRef": {
                      "type": "string"
                    },
                    "mount": {
                      "type": "string"
                    }
                  }
                }
              }
            },
            "kvVersion": {
              "type": "string",
              "enum": [
                "v1",
                "v2"
              ],
              "default": "v2"
            },
            "refreshAfter": {
              "type": "string"
            },
            "secrets": {
              "type": "object",
              "additionalProperties": false,
              "properties": {
                "admin_password_secret": {
                  "type": "object",
                  "properties": {
                    "mount": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "refreshAfter": {
                      "type": "string"
                    }
                  }
                },
                "db_fields_encryption_secret": {
                  "type": "object",
                  "properties": {
                    "mount": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "refreshAfter": {
                      "type": "string"
                    }
                  }
                },
                "database_secret": {
                  "type": "object",
                  "properties": {
                    "mount": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "refreshAfter": {
                      "type": "string"
                    }
                  }
                },
                "controller_postgres_configuration_secret": {
                  "type": "object",
                  "properties": {
                    "mount": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "refreshAfter": {
                      "type": "string"
                    }
                  }
                },
                "controller_secret_key_secret": {
                  "type": "object",
                  "properties": {
                    "mount": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "refreshAfter": {
                      "type": "string"
                    }
                  }
                },
                "eda_db_fields_encryption_secret": {
                  "type": "object",
                  "properties": {
                    "mount": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "refreshAfter": {
                      "type": "string"
                    }
                  }
                },
                "eda_database_secret": {
                  "type": "object",
                  "properties": {
                    "mount": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "refreshAfter": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "hub": {
      "type": "object",
      "properties": {
        "disabled": {
          "type": "boolean"
        },
        "file_storage_size": {
          "default": "100Gi",
          "description": "The size of the file storage; for example 100Gi.",
          "type": "string"
        },
        "file_storage_access_mode": {
          "description": "The file storage access mode.",
          "enum": [
            "",
            "ReadWriteMany",
            "ReadWriteOnce"
          ],
          "type": "string"
        },
        "file_storage_storage_class": {
          "description": "Storage class to use for the file persistentVolumeClaim",
          "type": "string"
        },
        "admin_password_secret": {
          "description": "Secret where the administrator password can be found",
          "type": "string"
        },
        "affinity": {
          "description": "Defines various deployment affinities",
          "properties": {
            "node_affinity": {
              "description": "Defines the node affinity for the deployment",
              "type": "object",
              "x-kubernetes-preserve-unknown-fields": true
            }
          },
          "type": "object"
        },
        "api": {
          "description": "The galaxy api deployment.",
          "properties": {
            "log_level": {
              "default": "INFO",
              "description": "The log level for the deployment.",
              "enum": [
                "DEBUG",
                "INFO",
                "WARNING",
                "ERROR",
                "CRITICAL"
              ],
              "type": "string"
            },
            "replicas": {
              "default": 1,
              "description": "The number of replicas for the deployment.",
              "format": "int32",
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the galaxy api container",
              "properties": {
                "limits": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "requests": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "bundle_cacert_secret": {
          "description": "Secret where the trusted Certificate Authority Bundle is stored",
          "type": "string"
        },
        "container_token_secret": {
          "description": "Secret where the container token certificates are stored",
          "type": "string"
        },
        "content": {
          "type": "object",
          "properties": {
            "replicas": {
              "default": 2,
              "description": "The number of replicas for the deployment.",
              "format": "int32",
              "type": "integer"
            },
            "log_level": {
              "default": "INFO",
              "description": "The log level for the deployment.",
              "enum": [
                "DEBUG",
                "INFO",
                "WARNING",
                "ERROR",
                "CRITICAL"
              ],
              "type": "string"
            },
            "resource_requirements": {
              "description": "Resource requirements for the galaxy content container",
              "properties": {
                "limits": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "requests": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            }
          }
        },
        "db_fields_encryption_secret": {
          "description": "Secret where the Fernet symmetric encryption key is stored",
          "type": "string"
        },
        "deployment_type": {
          "description": "Name of the deployment type",
          "type": "string"
        },
        "force_drop_db": {
          "default": false,
          "description": "(Deprecated) Force drop the database of the new Galaxy before restoring. USE WITH CAUTION!",
          "type": "boolean"
        },
        "gunicorn_api_workers": {
          "default": 2,
          "description": "The number of gunicorn workers to use for the api.",
          "type": "integer"
        },
        "gunicorn_content_workers": {
          "default": 2,
          "description": "The number of gunicorn workers to use for the content.",
          "type": "integer"
        },
        "gunicorn_timeout": {
          "default": 10,
          "description": "The timeout for the gunicorn process.",
          "type": "integer"
        },
        "haproxy_timeout": {
          "default": "180s",
          "description": "HAProxy timeout",
          "type": "string"
        },
        "hostname": {
          "description": "The hostname of the instance",
          "type": "string"
        },
        "idle_deployment": {
          "description": "Scale down deployments to put Galaxy into an idle state",
          "type": "boolean"
        },
        "image": {
          "description": "The image name (repo name) for the galaxy image.",
          "type": "string"
        },
        "image_pull_policy": {
          "default": "IfNotPresent",
          "description": "Image pull policy for container image",
          "enum": [
            "IfNotPresent",
            "Always",
            "Never"
          ],
          "type": "string"
        },
        "image_pull_secret": {
          "description": "The image pull secret (deprecated. Use image_pull_secrets instead)",
          "type": "string"
        },
        "image_pull_secrets": {
          "description": "The image pull secrets",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "image_version": {
          "description": "The image version for the galaxy image.",
          "type": "string"
        },
        "image_web": {
          "description": "The image name (repo name) for the galaxy-ui webserver image.",
          "type": "string"
        },
        "image_web_version": {
          "description": "The image version for the galaxy-ui webserver image.",
          "type": "string"
        },
        "ingress_annotations": {
          "description": "Annotations to add to the ingress",
          "type": "string"
        },
        "ingress_class_name": {
          "description": "The name of ingress class to use instead of the cluster default.",
          "type": "string"
        },
        "ingress_tls_secret": {
          "description": "Secret where the ingress TLS secret can be found",
          "type": "string"
        },
        "ingress_type": {
          "default": "Route",
          "description": "The ingress type to use to reach the deployed instance",
          "enum": [
            "none",
            "Ingress",
            "ingress",
            "Route",
            "route",
            "LoadBalancer",
            "loadbalancer",
            "NodePort",
            "nodeport"
          ],
          "type": "string"
        },
        "loadbalancer_port": {
          "default": 80,
          "description": "Port to use for the loadbalancer",
          "type": "integer"
        },
        "loadbalancer_protocol": {
          "default": "http",
          "description": "Protocol to use for the loadbalancer",
          "enum": [
            "http",
            "https"
          ],
          "type": "string"
        },
        "nginx_client_max_body_size": {
          "default": "10m",
          "description": "NGINX client max body size",
          "type": "string"
        },
        "nginx_proxy_connect_timeout": {
          "default": "15s",
          "description": "NGINX proxy connect timeout",
          "type": "string"
        },
        "nginx_proxy_read_timeout": {
          "default": "15s",
          "description": "NGINX proxy read timeout",
          "type": "string"
        },
        "nginx_proxy_send_timeout": {
          "default": "15s",
          "description": "NGINX proxy send timeout",
          "type": "string"
        },
        "no_log": {
          "default": true,
          "description": "Configure no_log for no_log tasks",
          "type": "boolean"
        },
        "node_selector": {
          "description": "nodeSelector for the Galaxy pods",
          "type": "string"
        },
        "nodeport_port": {
          "description": "Provide requested port value",
          "type": "string"
        },
        "object_storage_azure_secret": {
          "description": "The secret for Azure blob storage configuration.",
          "type": "string"
        },
        "object_storage_s3_secret": {
          "description": "The secret for S3 compliant object storage configuration.",
          "type": "string"
        },
        "postgres_configuration_secret": {
          "description": "Secret where the database configuration can be found",
          "type": "string"
        },
        "postgres_data_volume_init": {
          "description": "Sets permissions on the /var/lib/pgdata/data for postgres container using an init container (not Openshift)",
          "type": "boolean"
        },
        "postgres_extra_args": {
          "description": "(Deprecated, use postgres_extra_settings parameter) Define postgres configuration arguments to use",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "postgres_extra_settings": {
          "description": "PostgreSQL configuration settings to be added to postgresql.conf",
          "items": {
            "properties": {
              "setting": {
                "description": "PostgreSQL configuration parameter name",
                "type": "string"
              },
              "value": {
                "description": "PostgreSQL configuration parameter value",
                "type": "string"
              }
            },
            "required": [
              "setting",
              "value"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "postgres_host_auth_method": {
          "description": "The method to be used for database host authentication",
          "type": "string"
        },
        "postgres_image": {
          "description": "Registry path to the PostgreSQL container to use",
          "type": "string"
        },
        "postgres_init_container_commands": {
          "description": "Customize the postgres init container commands (Non Openshift)",
          "type": "string"
        },
        "postgres_initdb_args": {
          "description": "The arguments to be passed to initialize the database",
          "type": "string"
        },
        "postgres_keep_pvc_after_upgrade": {
          "description": "Specify whether or not to keep the old PVC after PostgreSQL upgrades",
          "type": "boolean"
        },
        "postgres_label_selector": {
          "description": "Label selector used to identify postgres pod for executing migration",
          "type": "string"
        },
        "postgres_migrant_configuration_secret": {
          "description": "Secret where the old database configuration can be found for data migration",
          "type": "string"
        },
        "postgres_resource_requirements": {
          "description": "Resource requirements for the PostgreSQL container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "default": "1000m",
                  "type": "string"
                },
                "memory": {
                  "default": "8Gi",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "default": "500m",
                  "type": "string"
                },
                "memory": {
                  "default": "2Gi",
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "postgres_selector": {
          "description": "nodeSelector for the Postgres pods",
          "type": "string"
        },
        "postgres_storage_class": {
          "description": "Storage class to use for the PostgreSQL PVC",
          "type": "string"
        },
        "postgres_storage_requirements": {
          "description": "Storage requirements for the PostgreSQL container",
          "properties": {
            "limits": {
              "properties": {
                "storage": {
                  "default": "50Gi",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "storage": {
                  "default": "8Gi",
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "postgres_tolerations": {
          "description": "node tolerations for the Postgres pods",
          "type": "string"
        },
        "public_base_url": {
          "description": "Public base URL",
          "type": "string"
        },
        "pulp_settings": {
          "description": "The pulp settings.",
          "properties": {
            "GALAXY_FEATURE_FLAGS": {
              "properties": {
                "execution_environments": {
                  "type": "boolean"
                }
              },
              "type": "object"
            },
            "debug": {
              "type": "string"
            }
          },
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "redis": {
          "description": "The galaxy redis deployment.",
          "properties": {
            "log_level": {
              "default": "INFO",
              "description": "The log level for the deployment.",
              "enum": [
                "DEBUG",
                "INFO",
                "WARNING",
                "ERROR",
                "CRITICAL"
              ],
              "type": "string"
            },
            "replicas": {
              "default": 1,
              "description": "(Deprecated) The number of replicas for redis is 1",
              "format": "int32",
              "maximum": 1,
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the galaxy redis container",
              "properties": {
                "limits": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "requests": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "redis_data_persistence": {
          "description": "Specify whether or not to have a redis pvc",
          "type": "boolean"
        },
        "redis_image": {
          "description": "The image name for the redis image.",
          "type": "string"
        },
        "redis_resource_requirements": {
          "description": "(Deprecated, use redis.resource_requirements instead) Resource requirements for the Redis container",
          "properties": {
            "limits": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "requests": {
              "properties": {
                "cpu": {
                  "type": "string"
                },
                "memory": {
                  "type": "string"
                },
                "storage": {
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "redis_storage_class": {
          "description": "Storage class to use for the Redis PVC",
          "type": "string"
        },
        "redis_storage_size": {
          "description": "Storage size to use for the Redis PVC",
          "type": "string"
        },
        "resource_manager": {
          "description": "The galaxy resource manager deployment.",
          "properties": {
            "replicas": {
              "default": 1,
              "description": "The number of replicas for the deployment.",
              "format": "int32",
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the galaxy resource manager container",
              "properties": {
                "limits": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "requests": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "route_host": {
          "description": "The DNS to use to points to the instance",
          "type": "string"
        },
        "route_tls_secret": {
          "description": "Secret where the TLS related credentials are stored",
          "type": "string"
        },
        "route_tls_termination_mechanism": {
          "default": "Edge",
          "description": "The secure TLS termination mechanism to use",
          "enum": [
            "Edge",
            "edge",
            "Passthrough",
            "passthrough"
          ],
          "type": "string"
        },
        "service_annotations": {
          "description": "Annotations to add to the service",
          "type": "string"
        },
        "signing_scripts_configmap": {
          "description": "ConfigMap where the signing scripts are stored",
          "type": "string"
        },
        "signing_secret": {
          "description": "Secret where the signing certificates are stored",
          "type": "string"
        },
        "sso_secret": {
          "description": "Secret where Single Sign-on configuration can be found",
          "type": "string"
        },
        "storage_type": {
          "description": "Configuration for the storage type to be utilized",
          "enum": [
            "file",
            "File",
            "s3",
            "S3",
            "azure",
            "Azure"
          ],
          "type": "string"
        },
        "tolerations": {
          "description": "node tolerations for the Galaxy pods",
          "type": "string"
        },
        "topology_spread_constraints": {
          "description": "topology rule(s) for the pods",
          "type": "string"
        },
        "web": {
          "description": "The galaxy web deployment.",
          "properties": {
            "replicas": {
              "default": 1,
              "description": "The number of replicas for the deployment.",
              "format": "int32",
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the galaxy web container",
              "properties": {
                "limits": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "requests": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            }
          },
          "type": "object"
        },
        "worker": {
          "type": "object",
          "properties": {
            "replicas": {
              "default": 2,
              "description": "The number of replicas for the deployment.",
              "format": "int32",
              "type": "integer"
            },
            "resource_requirements": {
              "description": "Resource requirements for the galaxy worker container",
              "properties": {
                "limits": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "requests": {
                  "properties": {
                    "cpu": {
                      "type": "string"
                    },
                    "memory": {
                      "type": "string"
                    },
                    "storage": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              },
              "type": "object"
            },
            "strategy": {
              "description": "The deployment strategy to use to replace existing pods with new ones.",
              "properties": {
                "rollingUpdate": {
                  "description": "Rolling update config params. Present only if DeploymentStrategyType = RollingUpdate. --- TODO: Update this to follow our convention for oneOf, whatever we decide it to be.",
                  "properties": {
                    "maxSurge": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    },
                    "maxUnavailable": {
                      "anyOf": [
                        {
                          "type": "integer"
                        },
                        {
                          "type": "string"
                        }
                      ],
                      "description": "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.",
                      "x-kubernetes-int-or-string": true
                    }
                  },
                  "type": "object"
                },
                "type": {
                  "description": "Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate.",
                  "type": "string"
                }
              },
              "type": "object"
            }
          }
        }
      }
    }
  },
  "definitions": {
    "resourceRequirements": {
      "type": "object",
      "properties": {
        "requests": {
          "type": "object",
          "properties": {
            "cpu": {
              "type": "string"
            },
            "memory": {
              "type": "string"
            }
          }
        },
        "limits": {
          "type": "object",
          "properties": {
            "cpu": {
              "type": "string"
            },
            "memory": {
              "type": "string"
            }
          }
        }
      }
    },
    "storageRequirements": {
      "type": "object",
      "properties": {
        "requests": {
          "type": "object",
          "properties": {
            "storage": {
              "type": "string"
            }
          }
        },
        "limits": {
          "type": "object",
          "properties": {
            "storage": {
              "type": "string"
            }
          }
        }
      }
    }
  }
}