cat swagger.json | jq '.definitions' | gron | grep -E "(IP|CIDR)"
json["io.k8s.api.admissionregistration.v1.WebhookClientConfig"].properties.url.description = "`url` gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified.\n\nThe `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address.\n\nPlease note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster.\n\nThe scheme must be \"https\"; the URL must begin with \"https://\".\n\nA path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier.\n\nAttempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"] = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].description = "Represents storage that is managed by an external CSI volume driver (Beta feature)";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.controllerExpandSecretRef = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.controllerExpandSecretRef.$ref = "#/definitions/io.k8s.api.core.v1.SecretReference";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.controllerExpandSecretRef.description = "ControllerExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerExpandVolume call. This is an alpha field and requires enabling ExpandCSIVolumes feature gate. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.controllerPublishSecretRef = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.controllerPublishSecretRef.$ref = "#/definitions/io.k8s.api.core.v1.SecretReference";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.controllerPublishSecretRef.description = "ControllerPublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerPublishVolume and ControllerUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.driver = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.driver.description = "Driver is the name of the driver to use for this volume. Required.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.driver.type = "string";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.fsType = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.fsType.description = "Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\".";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.fsType.type = "string";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.nodePublishSecretRef = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.nodePublishSecretRef.$ref = "#/definitions/io.k8s.api.core.v1.SecretReference";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.nodePublishSecretRef.description = "NodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.nodeStageSecretRef = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.nodeStageSecretRef.$ref = "#/definitions/io.k8s.api.core.v1.SecretReference";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.nodeStageSecretRef.description = "NodeStageSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodeStageVolume and NodeStageVolume and NodeUnstageVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.readOnly = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.readOnly.description = "Optional: The value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write).";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.readOnly.type = "boolean";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeAttributes = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeAttributes.additionalProperties = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeAttributes.additionalProperties.type = "string";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeAttributes.description = "Attributes of the volume to publish.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeAttributes.type = "object";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeHandle = {};
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeHandle.description = "VolumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required.";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].properties.volumeHandle.type = "string";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].required = [];
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].required[0] = "driver";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].required[1] = "volumeHandle";
json["io.k8s.api.core.v1.CSIPersistentVolumeSource"].type = "object";
json["io.k8s.api.core.v1.ClientIPConfig"] = {};
json["io.k8s.api.core.v1.ClientIPConfig"].description = "ClientIPConfig represents the configurations of Client IP based session affinity.";
json["io.k8s.api.core.v1.ClientIPConfig"].properties = {};
json["io.k8s.api.core.v1.ClientIPConfig"].properties.timeoutSeconds = {};
json["io.k8s.api.core.v1.ClientIPConfig"].properties.timeoutSeconds.description = "timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == \"ClientIP\". Default value is 10800(for 3 hours).";
json["io.k8s.api.core.v1.ClientIPConfig"].properties.timeoutSeconds.format = "int32";
json["io.k8s.api.core.v1.ClientIPConfig"].properties.timeoutSeconds.type = "integer";
json["io.k8s.api.core.v1.ClientIPConfig"].type = "object";
json["io.k8s.api.core.v1.ContainerPort"].properties.containerPort.description = "Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.";
json["io.k8s.api.core.v1.ContainerPort"].properties.hostIP = {};
json["io.k8s.api.core.v1.ContainerPort"].properties.hostIP.description = "What host IP to bind the external port to.";
json["io.k8s.api.core.v1.ContainerPort"].properties.hostIP.type = "string";
json["io.k8s.api.core.v1.DownwardAPIProjection"] = {};
json["io.k8s.api.core.v1.DownwardAPIProjection"].description = "Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.";
json["io.k8s.api.core.v1.DownwardAPIProjection"].properties = {};
json["io.k8s.api.core.v1.DownwardAPIProjection"].properties.items = {};
json["io.k8s.api.core.v1.DownwardAPIProjection"].properties.items.description = "Items is a list of DownwardAPIVolume file";
json["io.k8s.api.core.v1.DownwardAPIProjection"].properties.items.items = {};
json["io.k8s.api.core.v1.DownwardAPIProjection"].properties.items.items.$ref = "#/definitions/io.k8s.api.core.v1.DownwardAPIVolumeFile";
json["io.k8s.api.core.v1.DownwardAPIProjection"].properties.items.type = "array";
json["io.k8s.api.core.v1.DownwardAPIProjection"].type = "object";
json["io.k8s.api.core.v1.EndpointAddress"].description = "EndpointAddress is a tuple that describes single IP address.";
json["io.k8s.api.core.v1.EndpointAddress"].properties.ip.description = "The IP of this endpoint. May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16), or link-local multicast ((224.0.0.0/24). IPv6 is also accepted but not fully supported on all platforms. Also, certain kubernetes components, like kube-proxy, are not IPv6 ready.";
json["io.k8s.api.core.v1.EndpointPort"].properties.protocol.description = "The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.";
json["io.k8s.api.core.v1.EndpointSubset"].properties.addresses.description = "IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize.";
json["io.k8s.api.core.v1.EndpointSubset"].properties.notReadyAddresses.description = "IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check.";
json["io.k8s.api.core.v1.EndpointSubset"].properties.ports.description = "Port numbers available on the related IP addresses.";
json["io.k8s.api.core.v1.Endpoints"].properties.subsets.description = "The set of all endpoints is the union of all subsets. Addresses are placed into subsets according to the IPs they share. A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers) will result in the address being displayed in different subsets for the different ports. No address will appear in both Addresses and NotReadyAddresses in the same subset. Sets of addresses and ports that comprise a service.";
json["io.k8s.api.core.v1.EnvVarSource"].properties.fieldRef.description = "Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.";
json["io.k8s.api.core.v1.EphemeralContainer"].properties.targetContainerName.description = "If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container is run in whatever namespaces are shared for the pod. Note that the container runtime must support this feature.";
json["io.k8s.api.core.v1.HTTPGetAction"].properties.host.description = "Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.";
json["io.k8s.api.core.v1.HostAlias"].description = "HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.";
json["io.k8s.api.core.v1.HostAlias"].properties.hostnames.description = "Hostnames for the above IP address.";
json["io.k8s.api.core.v1.HostAlias"].properties.ip.description = "IP address of the host file entry.";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"] = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].description = "ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.chapAuthDiscovery = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.chapAuthDiscovery.description = "whether support iSCSI Discovery CHAP authentication";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.chapAuthDiscovery.type = "boolean";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.chapAuthSession = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.chapAuthSession.description = "whether support iSCSI Session CHAP authentication";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.chapAuthSession.type = "boolean";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.fsType = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.fsType.description = "Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.fsType.type = "string";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.initiatorName = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.initiatorName.description = "Custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface <target portal>:<volume name> will be created for the connection.";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.initiatorName.type = "string";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.iqn = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.iqn.description = "Target iSCSI Qualified Name.";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.iqn.type = "string";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.iscsiInterface = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.iscsiInterface.description = "iSCSI Interface Name that uses an iSCSI transport. Defaults to 'default' (tcp).";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.iscsiInterface.type = "string";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.lun = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.lun.description = "iSCSI Target Lun number.";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.lun.format = "int32";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.lun.type = "integer";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.portals = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.portals.description = "iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.portals.items = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.portals.items.type = "string";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.portals.type = "array";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.readOnly = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.readOnly.description = "ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false.";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.readOnly.type = "boolean";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.secretRef = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.secretRef.$ref = "#/definitions/io.k8s.api.core.v1.SecretReference";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.secretRef.description = "CHAP Secret for iSCSI target and initiator authentication";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.targetPortal = {};
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.targetPortal.description = "iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].properties.targetPortal.type = "string";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].required = [];
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].required[0] = "targetPortal";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].required[1] = "iqn";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].required[2] = "lun";
json["io.k8s.api.core.v1.ISCSIPersistentVolumeSource"].type = "object";
json["io.k8s.api.core.v1.ISCSIVolumeSource"].properties.portals.description = "iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).";
json["io.k8s.api.core.v1.ISCSIVolumeSource"].properties.targetPortal.description = "iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260).";
json["io.k8s.api.core.v1.LoadBalancerIngress"].properties.ip.description = "IP is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers)";
json["io.k8s.api.core.v1.NFSVolumeSource"].properties.server.description = "Server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs";
json["io.k8s.api.core.v1.NodeAddress"].properties.type.description = "Node address type, one of Hostname, ExternalIP or InternalIP.";
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDR = {};
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDR.description = "PodCIDR represents the pod IP range assigned to the node.";
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDR.type = "string";
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDRs = {};
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDRs.description = "podCIDRs represents the IP ranges assigned to the node for usage by Pods on that node. If this field is specified, the 0th entry must match the podCIDR field. It may contain at most 1 value for each of IPv4 and IPv6.";
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDRs.items = {};
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDRs.items.type = "string";
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDRs.type = "array";
json["io.k8s.api.core.v1.NodeSpec"].properties.podCIDRs["x-kubernetes-patch-strategy"] = "merge";
json["io.k8s.api.core.v1.PersistentVolumeSpec"].properties.csi.$ref = "#/definitions/io.k8s.api.core.v1.CSIPersistentVolumeSource";
json["io.k8s.api.core.v1.PersistentVolumeSpec"].properties.iscsi.$ref = "#/definitions/io.k8s.api.core.v1.ISCSIPersistentVolumeSource";
json["io.k8s.api.core.v1.PodDNSConfig"].properties.nameservers.description = "A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed.";
json["io.k8s.api.core.v1.PodIP"] = {};
json["io.k8s.api.core.v1.PodIP"].description = "IP address information for entries in the (plural) PodIPs field. Each entry includes:\n IP: An IP address allocated to the pod. Routable at least within the cluster.";
json["io.k8s.api.core.v1.PodIP"].properties = {};
json["io.k8s.api.core.v1.PodIP"].properties.ip = {};
json["io.k8s.api.core.v1.PodIP"].properties.ip.description = "ip is an IP address (IPv4 or IPv6) assigned to the pod";
json["io.k8s.api.core.v1.PodIP"].properties.ip.type = "string";
json["io.k8s.api.core.v1.PodIP"].type = "object";
json["io.k8s.api.core.v1.PodSpec"].properties.hostAliases.description = "HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified. This is only valid for non-hostNetwork pods.";
json["io.k8s.api.core.v1.PodSpec"].properties.hostIPC = {};
json["io.k8s.api.core.v1.PodSpec"].properties.hostIPC.description = "Use the host's ipc namespace. Optional: Default to false.";
json["io.k8s.api.core.v1.PodSpec"].properties.hostIPC.type = "boolean";
json["io.k8s.api.core.v1.PodStatus"].properties.hostIP = {};
json["io.k8s.api.core.v1.PodStatus"].properties.hostIP.description = "IP address of the host to which the pod is assigned. Empty if not yet scheduled.";
json["io.k8s.api.core.v1.PodStatus"].properties.hostIP.type = "string";
json["io.k8s.api.core.v1.PodStatus"].properties.podIP = {};
json["io.k8s.api.core.v1.PodStatus"].properties.podIP.description = "IP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.";
json["io.k8s.api.core.v1.PodStatus"].properties.podIP.type = "string";
json["io.k8s.api.core.v1.PodStatus"].properties.podIPs = {};
json["io.k8s.api.core.v1.PodStatus"].properties.podIPs.description = "podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet.";
json["io.k8s.api.core.v1.PodStatus"].properties.podIPs.items = {};
json["io.k8s.api.core.v1.PodStatus"].properties.podIPs.items.$ref = "#/definitions/io.k8s.api.core.v1.PodIP";
json["io.k8s.api.core.v1.PodStatus"].properties.podIPs.type = "array";
json["io.k8s.api.core.v1.PodStatus"].properties.podIPs["x-kubernetes-patch-merge-key"] = "ip";
json["io.k8s.api.core.v1.PodStatus"].properties.podIPs["x-kubernetes-patch-strategy"] = "merge";
json["io.k8s.api.core.v1.ServicePort"].properties.nodePort.description = "The port on each node on which this service is exposed when type is NodePort or LoadBalancer. Usually assigned by the system. If a value is specified, in-range, and not in use it will be used, otherwise the operation will fail. If not specified, a port will be allocated if this Service requires one. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type from NodePort to ClusterIP). More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport";
json["io.k8s.api.core.v1.ServicePort"].properties.protocol.description = "The IP protocol for this port. Supports \"TCP\", \"UDP\", and \"SCTP\". Default is TCP.";
json["io.k8s.api.core.v1.ServicePort"].properties.targetPort.description = "Number or name of the port to access on the pods targeted by the service. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. If this is a string, it will be looked up as a named port in the target Pod's container ports. If this is not specified, the value of the 'port' field is used (an identity map). This field is ignored for services with clusterIP=None, and should be omitted or set equal to the 'port' field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service";
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIP = {};
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIP.description = "clusterIP is the IP address of the service and is usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be blank) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies";
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIP.type = "string";
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIPs = {};
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIPs.description = "ClusterIPs is a list of IP addresses assigned to this service, and are usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be empty) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are \"None\", empty string (\"\"), or a valid IP address. Setting this to \"None\" makes a \"headless service\" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. If this field is not specified, it will be initialized from the clusterIP field. If this field is specified, clients must ensure that clusterIPs[0] and clusterIP have the same value.\n\nUnless the \"IPv6DualStack\" feature gate is enabled, this field is limited to one value, which must be the same as the clusterIP field. If the feature gate is enabled, this field may hold a maximum of two entries (dual-stack IPs, in either order). These IPs must correspond to the values of the ipFamilies field. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies";
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIPs.items = {};
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIPs.items.type = "string";
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIPs.type = "array";
json["io.k8s.api.core.v1.ServiceSpec"].properties.clusterIPs["x-kubernetes-list-type"] = "atomic";
json["io.k8s.api.core.v1.ServiceSpec"].properties.externalIPs = {};
json["io.k8s.api.core.v1.ServiceSpec"].properties.externalIPs.description = "externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system.";
json["io.k8s.api.core.v1.ServiceSpec"].properties.externalIPs.items = {};
json["io.k8s.api.core.v1.ServiceSpec"].properties.externalIPs.items.type = "string";
json["io.k8s.api.core.v1.ServiceSpec"].properties.externalIPs.type = "array";
json["io.k8s.api.core.v1.ServiceSpec"].properties.externalTrafficPolicy.description = "externalTrafficPolicy denotes if this Service desires to route external traffic to node-local or cluster-wide endpoints. \"Local\" preserves the client source IP and avoids a second hop for LoadBalancer and Nodeport type services, but risks potentially imbalanced traffic spreading. \"Cluster\" obscures the client source IP and may cause a second hop to another node, but should have good overall load-spreading.";
json["io.k8s.api.core.v1.ServiceSpec"].properties.ipFamilies.description = "IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service, and is gated by the \"IPv6DualStack\" feature gate. This field is usually assigned automatically based on cluster configuration and the ipFamilyPolicy field. If this field is specified manually, the requested family is available in the cluster, and ipFamilyPolicy allows it, it will be used; otherwise creation of the service will fail. This field is conditionally mutable: it allows for adding or removing a secondary IP family, but it does not allow changing the primary IP family of the Service. Valid values are \"IPv4\" and \"IPv6\". This field only applies to Services of types ClusterIP, NodePort, and LoadBalancer, and does apply to \"headless\" services. This field will be wiped when updating a Service to type ExternalName.\n\nThis field may hold a maximum of two entries (dual-stack families, in either order). These families must correspond to the values of the clusterIPs field, if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field.";
json["io.k8s.api.core.v1.ServiceSpec"].properties.ipFamilyPolicy.description = "IPFamilyPolicy represents the dual-stack-ness requested or required by this Service, and is gated by the \"IPv6DualStack\" feature gate. If there is no value provided, then this field will be set to SingleStack. Services can be \"SingleStack\" (a single IP family), \"PreferDualStack\" (two IP families on dual-stack configured clusters or a single IP family on single-stack clusters), or \"RequireDualStack\" (two IP families on dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs fields depend on the value of this field. This field will be wiped when updating a service to type ExternalName.";
json["io.k8s.api.core.v1.ServiceSpec"].properties.loadBalancerIP = {};
json["io.k8s.api.core.v1.ServiceSpec"].properties.loadBalancerIP.description = "Only applies to Service Type: LoadBalancer LoadBalancer will get created with the IP specified in this field. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature.";
json["io.k8s.api.core.v1.ServiceSpec"].properties.loadBalancerIP.type = "string";
json["io.k8s.api.core.v1.ServiceSpec"].properties.loadBalancerSourceRanges.description = "If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature.\" More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/";
json["io.k8s.api.core.v1.ServiceSpec"].properties.selector.description = "Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/";
json["io.k8s.api.core.v1.ServiceSpec"].properties.sessionAffinity.description = "Supports \"ClientIP\" and \"None\". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies";
json["io.k8s.api.core.v1.ServiceSpec"].properties.type.description = "type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \"ClusterIP\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is \"None\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. \"NodePort\" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. \"LoadBalancer\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. \"ExternalName\" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types";
json["io.k8s.api.core.v1.SessionAffinityConfig"].properties.clientIP = {};
json["io.k8s.api.core.v1.SessionAffinityConfig"].properties.clientIP.$ref = "#/definitions/io.k8s.api.core.v1.ClientIPConfig";
json["io.k8s.api.core.v1.SessionAffinityConfig"].properties.clientIP.description = "clientIP contains the configurations of Client IP based session affinity.";
json["io.k8s.api.core.v1.TCPSocketAction"].properties.host.description = "Optional: Host name to connect to, defaults to the pod IP.";
json["io.k8s.api.core.v1.VolumeProjection"].properties.downwardAPI.$ref = "#/definitions/io.k8s.api.core.v1.DownwardAPIProjection";
json["io.k8s.api.discovery.v1.EndpointPort"].properties.protocol.description = "The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.";
json["io.k8s.api.discovery.v1.EndpointSlice"].properties.addressType.description = "addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name.";
json["io.k8s.api.discovery.v1beta1.EndpointPort"].properties.protocol.description = "The IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP.";
json["io.k8s.api.discovery.v1beta1.EndpointSlice"].properties.addressType.description = "addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name.";
json["io.k8s.api.networking.v1.IPBlock"] = {};
json["io.k8s.api.networking.v1.IPBlock"].description = "IPBlock describes a particular CIDR (Ex. \"192.168.1.1/24\",\"2001:db9::/64\") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule.";
json["io.k8s.api.networking.v1.IPBlock"].properties = {};
json["io.k8s.api.networking.v1.IPBlock"].properties.cidr = {};
json["io.k8s.api.networking.v1.IPBlock"].properties.cidr.description = "CIDR is a string representing the IP Block Valid examples are \"192.168.1.1/24\" or \"2001:db9::/64\"";
json["io.k8s.api.networking.v1.IPBlock"].properties.cidr.type = "string";
json["io.k8s.api.networking.v1.IPBlock"].properties.except = {};
json["io.k8s.api.networking.v1.IPBlock"].properties.except.description = "Except is a slice of CIDRs that should not be included within an IP Block Valid examples are \"192.168.1.1/24\" or \"2001:db9::/64\" Except values will be rejected if they are outside the CIDR range";
json["io.k8s.api.networking.v1.IPBlock"].properties.except.items = {};
json["io.k8s.api.networking.v1.IPBlock"].properties.except.items.type = "string";
json["io.k8s.api.networking.v1.IPBlock"].properties.except.type = "array";
json["io.k8s.api.networking.v1.IPBlock"].required = [];
json["io.k8s.api.networking.v1.IPBlock"].required[0] = "cidr";
json["io.k8s.api.networking.v1.IPBlock"].type = "object";
json["io.k8s.api.networking.v1.IngressRule"].properties.host.description = "Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \"host\" part of the URI as defined in RFC 3986: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to\n the IP in the Spec of the parent Ingress.\n2. The `:` delimiter is not respected because ports are not allowed.\n\t Currently the port of an Ingress is implicitly :80 for http and\n\t :443 for https.\nBoth these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue.\n\nHost can be \"precise\" which is a domain name without the terminating dot of a network host (e.g. \"foo.bar.com\") or \"wildcard\", which is a domain name prefixed with a single wildcard label (e.g. \"*.foo.com\"). The wildcard character '*' must appear by itself as the first DNS label and matches only a single label. You cannot have a wildcard label by itself (e.g. Host == \"*\"). Requests will be matched against the Host field in the following way: 1. If Host is precise, the request matches this rule if the http host header is equal to Host. 2. If Host is a wildcard, then the request matches this rule if the http host header is to equal to the suffix (removing the first label) of the wildcard rule.";
json["io.k8s.api.networking.v1.NetworkPolicyPeer"].properties.ipBlock.$ref = "#/definitions/io.k8s.api.networking.v1.IPBlock";
json["io.k8s.api.networking.v1.NetworkPolicyPeer"].properties.ipBlock.description = "IPBlock defines policy on a particular IPBlock. If this field is set then neither of the other fields can be.";
json["io.k8s.api.policy.v1beta1.PodSecurityPolicySpec"].properties.hostIPC = {};
json["io.k8s.api.policy.v1beta1.PodSecurityPolicySpec"].properties.hostIPC.description = "hostIPC determines if the policy allows the use of HostIPC in the pod spec.";
json["io.k8s.api.policy.v1beta1.PodSecurityPolicySpec"].properties.hostIPC.type = "boolean";
json["io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps"].properties.format.description = "format is an OpenAPI v3 format string. Unknown formats are ignored. The following formats are validated:\n\n- bsonobjectid: a bson object ID, i.e. a 24 characters hex string - uri: an URI as parsed by Golang net/url.ParseRequestURI - email: an email address as parsed by Golang net/mail.ParseAddress - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. - ipv4: an IPv4 IP as parsed by Golang net.ParseIP - ipv6: an IPv6 IP as parsed by Golang net.ParseIP - cidr: a CIDR as parsed by Golang net.ParseCIDR - mac: a MAC address as parsed by Golang net.ParseMAC - uuid: an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid3: an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid4: an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - uuid5: an UUID5 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - isbn: an ISBN10 or ISBN13 number string like \"0321751043\" or \"978-0321751041\" - isbn10: an ISBN10 number string like \"0321751043\" - isbn13: an ISBN13 number string like \"978-0321751041\" - creditcard: a credit card number defined by the regex ^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})$ with any non digit characters mixed in - ssn: a U.S. social security number following the regex ^\\d{3}[- ]?\\d{2}[- ]?\\d{4}$ - hexcolor: an hexadecimal color code like \"#FFFFFF: following the regex ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ - rgbcolor: an RGB color code like rgb like \"rgb(255,255,2559\" - byte: base64 encoded binary data - password: any kind of string - date: a date string like \"2006-01-02\" as defined by full-date in RFC3339 - duration: a duration string like \"22 ns\" as parsed by Golang time.ParseDuration or compatible with Scala duration format - datetime: a date time string like \"2014-12-15T19:30:20.000Z\" as defined by date-time in RFC3339.";
json["io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig"].properties.url.description = "url gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified.\n\nThe `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address.\n\nPlease note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster.\n\nThe scheme must be \"https\"; the URL must begin with \"https://\".\n\nA path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier.\n\nAttempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either.";
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup"].properties.serverAddressByClientCIDRs = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup"].properties.serverAddressByClientCIDRs.description = "a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP.";
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup"].properties.serverAddressByClientCIDRs.items = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup"].properties.serverAddressByClientCIDRs.items.$ref = "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR";
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup"].properties.serverAddressByClientCIDRs.type = "array";
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions"].properties.serverAddressByClientCIDRs = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions"].properties.serverAddressByClientCIDRs.description = "a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP.";
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions"].properties.serverAddressByClientCIDRs.items = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions"].properties.serverAddressByClientCIDRs.items.$ref = "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR";
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions"].properties.serverAddressByClientCIDRs.type = "array";
json["io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions"].required[1] = "serverAddressByClientCIDRs";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"] = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].description = "ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].properties = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].properties.clientCIDR = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].properties.clientCIDR.description = "The CIDR with which clients can match their IP to figure out the server address that they should use.";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].properties.clientCIDR.type = "string";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].properties.serverAddress = {};
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].properties.serverAddress.description = "Address of this server, suitable for a client that matches the above CIDR. This can be a hostname, hostname:port, IP or IP:port.";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].properties.serverAddress.type = "string";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].required = [];
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].required[0] = "clientCIDR";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].required[1] = "serverAddress";
json["io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"].type = "object";